switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/bg-agent-progress-card-757.test.ts

@@ -1,201 +0,0 @@
-/**
- * Regression tests for #757 — progress card goes silent for background
- * Agent workers (run_in_background: true).
- *
- * Root cause: `applyToolUse` in fleet-state.ts only promoted `stuck →
- * running`; background members stayed at `status: 'background'` even
- * while actively running tools. The fleet row rendered ⏸ idle instead
- * of ↻ + last-tool, so the card appeared frozen.
- *
- * Fix: applyToolUse now also promotes `background → running` on the
- * first live tool event. A separate sticky `isBackgroundDispatch` flag
- * preserves the background-carry semantics used by hasLiveBackground
- * (keeps PerChatState alive past parent turn_end until bg member
- * reaches terminal status).
- */
-
-import { describe, it, expect } from 'vitest'
-import { createProgressDriver } from '../progress-card-driver.js'
-import { applyToolUse, createFleetMember, hasLiveBackground } from '../fleet-state.js'
-import type { SessionEvent } from '../session-tail.js'
-
-const T0 = 1_700_000_000_000
-
-// ─── Pure-function unit tests ────────────────────────────────────────────────
-
-describe('applyToolUse: background → running promotion (#757)', () => {
-  it('promotes background to running on first tool event', () => {
-    const m = { ...createFleetMember({ agentId: 'a', role: 'worker', startedAt: T0, originatingTurnKey: 'k', isBackgroundDispatch: true }), status: 'background' as const }
-    const after = applyToolUse(m, 'Read', { file_path: '/foo/bar.ts' }, T0 + 1000)
-    expect(after.status).toBe('running')
-    expect(after.lastTool?.name).toBe('Read')
-  })
-
-  it('preserves isBackgroundDispatch after promotion', () => {
-    const m = { ...createFleetMember({ agentId: 'a', role: 'worker', startedAt: T0, originatingTurnKey: 'k', isBackgroundDispatch: true }), status: 'background' as const }
-    const after = applyToolUse(m, 'Bash', { command: 'ls' }, T0 + 1000)
-    expect(after.isBackgroundDispatch).toBe(true)
-  })
-
-  it('does not affect foreground members (status stays running)', () => {
-    const m = createFleetMember({ agentId: 'a', role: 'worker', startedAt: T0, originatingTurnKey: 'k' })
-    const after = applyToolUse(m, 'Read', { file_path: '/x' }, T0 + 1000)
-    expect(after.status).toBe('running')
-    expect(after.isBackgroundDispatch).toBe(false)
-  })
-})
-
-describe('hasLiveBackground: sticky flag survives status promotion (#757)', () => {
-  it('returns true when background member is promoted to running (not yet terminal)', () => {
-    const fleet = new Map([
-      ['a', { ...createFleetMember({ agentId: 'a', role: 'w', startedAt: T0, originatingTurnKey: 'k', isBackgroundDispatch: true }), status: 'running' as const }],
-    ])
-    expect(hasLiveBackground(fleet)).toBe(true)
-  })
-
-  it('returns false when background member reaches terminal status', () => {
-    const fleet = new Map([
-      ['a', { ...createFleetMember({ agentId: 'a', role: 'w', startedAt: T0, originatingTurnKey: 'k', isBackgroundDispatch: true }), status: 'done' as const, terminalAt: T0 + 5000 }],
-    ])
-    expect(hasLiveBackground(fleet)).toBe(false)
-  })
-
-  it('returns false when no members are background dispatches', () => {
-    const fleet = new Map([
-      ['a', createFleetMember({ agentId: 'a', role: 'w', startedAt: T0, originatingTurnKey: 'k' })],
-    ])
-    expect(hasLiveBackground(fleet)).toBe(false)
-  })
-})
-
-// ─── Integration: driver-level lifecycle ─────────────────────────────────────
-
-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)
-    },
-  })
-  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 timers.splice(timers.indexOf(t), 1)
-    }
-    now = target
-  }
-  return { driver, completions, advance, getNow: () => now }
-}
-
-const enqueue = (chatId: string): SessionEvent => ({
-  kind: 'enqueue',
-  chatId,
-  messageId: '1',
-  threadId: null,
-  rawContent: `<channel chat_id="${chatId}">go</channel>`,
-})
-
-describe('driver integration: bg worker tool activity (#757)', () => {
-  it('background fleet member promotes to running when tool events arrive', () => {
-    const { driver } = harness()
-    const CHAT = 'c1'
-    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: 'sa1', firstPromptText: 'bg work' }, CHAT)
-
-    // Initial state: background.
-    expect(driver.peekFleet(CHAT)!.get('sa1')!.status).toBe('background')
-
-    // Tool activity arrives from the sub-agent JSONL.
-    driver.ingest({ kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Bash', input: { command: 'npm test' } }, CHAT)
-
-    const m = driver.peekFleet(CHAT)!.get('sa1')!
-    // Promoted to running — card now shows active tool work.
-    expect(m.status).toBe('running')
-    expect(m.lastTool?.name).toBe('Bash')
-    // Sticky flag preserved — bg-carry still works.
-    expect(m.isBackgroundDispatch).toBe(true)
-  })
-
-  it('background carry survives promotion: turn completion holds until bg reaches terminal', () => {
-    const { driver, completions } = harness()
-    const CHAT = 'c2'
-    driver.ingest(enqueue(CHAT), null)
-    driver.ingest(
-      { kind: 'tool_use', toolName: 'Agent', toolUseId: 'tu1', input: { prompt: 'bg', run_in_background: true } },
-      CHAT,
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'bg' }, CHAT)
-    // Bg worker starts doing tool work — status becomes running.
-    driver.ingest({ kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Read', input: { file_path: '/a' } }, CHAT)
-    expect(driver.peekFleet(CHAT)!.get('sa1')!.status).toBe('running')
-
-    driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, CHAT)
-    driver.recordOutboundDelivered(CHAT)
-    // Parent ends while bg worker is still running.
-    driver.ingest({ kind: 'turn_end', durationMs: 100 }, CHAT)
-
-    // Turn completion must NOT fire — bg worker is still active.
-    expect(completions.length).toBe(0)
-
-    // Bg worker finishes.
-    driver.ingest({ kind: 'sub_agent_turn_end', agentId: 'sa1' }, CHAT)
-    expect(completions.length).toBe(1)
-  })
-
-  it('terminal state reached after promotion fires completion correctly', () => {
-    const { driver, completions } = harness()
-    const CHAT = 'c3'
-    driver.ingest(enqueue(CHAT), null)
-    driver.ingest(
-      { kind: 'tool_use', toolName: 'Agent', toolUseId: 'tu1', input: { prompt: 'bg', run_in_background: true } },
-      CHAT,
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'bg' }, CHAT)
-    driver.ingest({ kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Write', input: { file_path: '/out.ts' } }, CHAT)
-
-    driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, CHAT)
-    driver.recordOutboundDelivered(CHAT)
-    driver.ingest({ kind: 'turn_end', durationMs: 100 }, CHAT)
-    // Peek before sub_agent_turn_end so fleet is still live.
-    expect(driver.peekFleet(CHAT)!.get('sa1')!.status).toBe('running')
-    driver.ingest({ kind: 'sub_agent_turn_end', agentId: 'sa1' }, CHAT)
-    expect(completions.length).toBe(1)
-  })
-})

package/telegram-plugin/tests/boot-card-account-quota.test.ts

@@ -1,137 +0,0 @@
-/**
- * Boot card per-account quota rendering — issue #708.
- *
- * Verifies:
- *   - When `accounts` is absent / empty, the card stays silent (today's
- *     contract — no accounts section).
- *   - When `accounts` is present, the card appends an "Accounts (N)"
- *     header and one line per account with 5h % / 7d % / nearest reset.
- *   - The ▶ marker tags the active-for-this-agent account; ↳ tags the
- *     rest.
- *   - HTML escaping on account labels.
- *   - Account with no quota fields (label only) renders the row without
- *     any percent / reset suffix.
- */
-
-import { describe, it, expect } from 'vitest'
-import {
-  renderBootCard,
-  renderAccountRows,
-} from '../gateway/boot-card.js'
-import type { AccountSummary } from '../auth-dashboard.js'
-
-const NOW = new Date('2026-05-05T10:00:00Z')
-
-function mk(overrides: Partial<AccountSummary> = {}): AccountSummary {
-  return {
-    label: 'pixsoul@gmail.com',
-    health: 'healthy',
-    enabledHere: true,
-    activeForThisAgent: false,
-    fiveHourPct: 10,
-    sevenDayPct: 79,
-    fiveHourResetAt: NOW.getTime() + 2 * 3600_000 + 14 * 60_000,
-    sevenDayResetAt: NOW.getTime() + 5 * 86_400_000,
-    ...overrides,
-  }
-}
-
-describe('renderBootCard — per-account quota (issue #708)', () => {
-  it('omits the accounts section when accounts is undefined', () => {
-    const out = renderBootCard({ agentName: 'clerk', version: 'v0.7.0' })
-    expect(out).not.toContain('Accounts')
-  })
-
-  it('omits the accounts section when accounts is empty', () => {
-    const out = renderBootCard({
-      agentName: 'clerk',
-      version: 'v0.7.0',
-      accounts: [],
-    })
-    expect(out).not.toContain('Accounts')
-  })
-
-  it('renders the active account with ▶ and inline 5h / 7d / reset', () => {
-    const out = renderBootCard({
-      agentName: 'clerk',
-      version: 'v0.7.0',
-      accounts: [mk({ activeForThisAgent: true })],
-      now: NOW,
-    })
-    expect(out).toContain('Accounts (1)')
-    expect(out).toContain('▶')
-    expect(out).toContain('pixsoul@gmail.com')
-    expect(out).toContain('10%')
-    expect(out).toContain('79%')
-    expect(out).toContain('5h resets in')
-  })
-
-  it('renders fallback accounts with ↳', () => {
-    const out = renderBootCard({
-      agentName: 'clerk',
-      version: 'v0.7.0',
-      now: NOW,
-      accounts: [
-        mk({ activeForThisAgent: true }),
-        mk({ label: 'ken+work@example.com', activeForThisAgent: false }),
-      ],
-    })
-    expect(out).toContain('Accounts (2)')
-    expect(out).toMatch(/↳ <code>ken\+work@example\.com<\/code>/)
-  })
-
-  it('escapes HTML in labels', () => {
-    const out = renderAccountRows(
-      [mk({ label: 'evil<script>', activeForThisAgent: true })],
-      NOW,
-    )
-    expect(out.join('\n')).toContain('evil&lt;script&gt;')
-    expect(out.join('\n')).not.toContain('<script>')
-  })
-
-  it('renders a row with no quota numbers as label-only', () => {
-    const summary: AccountSummary = {
-      label: 'just-added',
-      health: 'healthy',
-      enabledHere: true,
-      activeForThisAgent: false,
-    }
-    const out = renderAccountRows([summary], NOW)
-    expect(out).toHaveLength(2)
-    expect(out[1]).toBe('↳ <code>just-added</code>')
-  })
-
-  it('shows 7d reset when 5h reset is missing', () => {
-    const out = renderAccountRows(
-      [
-        mk({
-          activeForThisAgent: true,
-          fiveHourPct: 0,
-          sevenDayPct: 99,
-          fiveHourResetAt: undefined,
-          sevenDayResetAt: NOW.getTime() + 86_400_000 + 3 * 3600_000,
-        }),
-      ],
-      NOW,
-    )
-    expect(out.join('\n')).toContain('7d resets in')
-  })
-
-  it('drops the reset suffix once the reset timestamp has elapsed', () => {
-    const out = renderAccountRows(
-      [
-        mk({
-          activeForThisAgent: true,
-          fiveHourPct: 0,
-          sevenDayPct: 0,
-          fiveHourResetAt: NOW.getTime() - 60_000,
-          sevenDayResetAt: undefined,
-        }),
-      ],
-      NOW,
-    )
-    // Past-reset timestamps return "" from formatNearestAccountResetSuffix,
-    // so the line should not contain "resets in" at all.
-    expect(out.join('\n')).not.toContain('resets in')
-  })
-})

package/telegram-plugin/tests/card-event-log.test.ts

@@ -1,145 +0,0 @@
-/**
- * Tests for the structured card-event logger — the audit trail for the
- * pinned progress card lifecycle. Mirrors `pin-event-log.test.ts`.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { mkdtempSync, readFileSync, existsSync, rmSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import {
-  logCardEvent,
-  emitCardEvent,
-  resolveCardEventPath,
-  _resetForTests,
-  type CardEvent,
-} from '../card-event-log.js'
-
-let tmpDir: string
-const prevStateDir = process.env.STATE_DIR
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), 'card-event-log-'))
-  _resetForTests()
-})
-
-afterEach(() => {
-  _resetForTests()
-  if (prevStateDir === undefined) delete process.env.STATE_DIR
-  else process.env.STATE_DIR = prevStateDir
-  try { rmSync(tmpDir, { recursive: true, force: true }) } catch { /* ignore */ }
-})
-
-describe('logCardEvent (injected writer)', () => {
-  it('writes one JSON line per call', () => {
-    const lines: string[] = []
-    const ev: CardEvent = {
-      ts: 1700000000000,
-      agent: 'klanker',
-      chatId: '100',
-      turnKey: '100::1',
-      cardMessageId: 4242,
-      event: 'rendered',
-      htmlHash: 'abc123def456',
-    }
-    logCardEvent(ev, (l) => lines.push(l))
-    expect(lines).toHaveLength(1)
-    expect(lines[0].endsWith('\n')).toBe(true)
-    const payload = JSON.parse(lines[0].trimEnd())
-    expect(payload).toEqual(ev)
-  })
-
-  it('omits undefined optional fields cleanly', () => {
-    const lines: string[] = []
-    logCardEvent(
-      {
-        ts: 1,
-        agent: 'a',
-        chatId: 'c',
-        turnKey: 'c::1',
-        event: 'finalized',
-      },
-      (l) => lines.push(l),
-    )
-    const raw = lines[0].trimEnd()
-    expect(raw).not.toContain('undefined')
-    const payload = JSON.parse(raw)
-    expect(payload.cardMessageId).toBeUndefined()
-    expect(payload.reason).toBeUndefined()
-    expect(payload.subagents).toBeUndefined()
-  })
-
-  it('preserves subagents array and durationMs', () => {
-    const lines: string[] = []
-    logCardEvent(
-      {
-        ts: 2,
-        agent: 'a',
-        chatId: 'c',
-        turnKey: 'c::1',
-        event: 'deferred',
-        reason: 'in-flight-sub-agents',
-        subagents: ['agent-1', 'agent-2'],
-        durationMs: 12345,
-      },
-      (l) => lines.push(l),
-    )
-    const payload = JSON.parse(lines[0].trimEnd())
-    expect(payload.subagents).toEqual(['agent-1', 'agent-2'])
-    expect(payload.durationMs).toBe(12345)
-    expect(payload.reason).toBe('in-flight-sub-agents')
-  })
-})
-
-describe('emitCardEvent', () => {
-  it('fills ts when omitted', () => {
-    const lines: string[] = []
-    const before = Date.now()
-    emitCardEvent(
-      { agent: 'a', chatId: 'c', turnKey: 'c::1', event: 'edited' },
-      (l) => lines.push(l),
-    )
-    const after = Date.now()
-    const payload = JSON.parse(lines[0].trimEnd())
-    expect(payload.ts).toBeGreaterThanOrEqual(before)
-    expect(payload.ts).toBeLessThanOrEqual(after)
-  })
-
-  it('respects an explicit ts', () => {
-    const lines: string[] = []
-    emitCardEvent(
-      { ts: 999, agent: 'a', chatId: 'c', turnKey: 'c::1', event: 'edited' },
-      (l) => lines.push(l),
-    )
-    expect(JSON.parse(lines[0].trimEnd()).ts).toBe(999)
-  })
-})
-
-describe('resolveCardEventPath', () => {
-  it('returns <STATE_DIR>/card-events.jsonl when STATE_DIR is set', () => {
-    expect(resolveCardEventPath({ STATE_DIR: '/tmp/x' })).toBe('/tmp/x/card-events.jsonl')
-  })
-
-  it('returns null when STATE_DIR is unset', () => {
-    expect(resolveCardEventPath({})).toBeNull()
-  })
-
-  it('returns null when STATE_DIR is empty', () => {
-    expect(resolveCardEventPath({ STATE_DIR: '' })).toBeNull()
-  })
-})
-
-describe('default writer (filesystem)', () => {
-  it('appends to <STATE_DIR>/card-events.jsonl when STATE_DIR is set', () => {
-    process.env.STATE_DIR = tmpDir
-    _resetForTests()
-    emitCardEvent({ agent: 'a', chatId: 'c', turnKey: 'c::1', event: 'rendered' })
-    emitCardEvent({ agent: 'a', chatId: 'c', turnKey: 'c::1', event: 'finalized' })
-    const target = join(tmpDir, 'card-events.jsonl')
-    expect(existsSync(target)).toBe(true)
-    const contents = readFileSync(target, 'utf8').trimEnd().split('\n')
-    expect(contents).toHaveLength(2)
-    expect(JSON.parse(contents[0]).event).toBe('rendered')
-    expect(JSON.parse(contents[1]).event).toBe('finalized')
-  })
-})