switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/progress-card-memory-bounds.test.ts

@@ -1,84 +0,0 @@
-/**
- * PR-C2 — end-to-end memory bounds: drive 100 turn cycles and assert
- * every internal Map remains bounded.
- *
- * Companion to PR-B's targeted eviction test, which drove only 20
- * cycles and asserted on `seenEnqueueMsgIds` / `pendingSyncEchoes`.
- * This larger run is a regression net for "everything else" — if a
- * future refactor forgets to evict any new map keyed by chat/turn,
- * the size invariant blows up here even when the PR-B test still
- * passes.
- *
- * fails when: any of the per-chat/per-turn Maps in `_debugGetMaps`
- * grows linearly with turn count (e.g. cleanup is removed from
- * completeTurnFully, or a new Map is added without an eviction hook).
- */
-import { describe, it, expect } from 'vitest'
-import { makeHarness, enqueue } from './_progress-card-harness.js'
-
-describe('PR-C2: end-to-end memory bounds across 100 turn cycles', () => {
-  it('all _debugGetMaps Maps stay bounded', () => {
-    const { driver, advance } = makeHarness({
-      heartbeatMs: 5_000,
-      promoteAfterMs: 999_999,
-    })
-    const maps = driver._debugGetMaps!()
-
-    for (let i = 0; i < 100; i++) {
-      driver.ingest(enqueue('chatA'), null)
-      driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, 'chatA')
-      driver.recordOutboundDelivered('chatA')
-      driver.ingest({ kind: 'turn_end', durationMs: 50 }, 'chatA')
-      // Advance well past TTLs (60s) and the eviction throttle (~30s).
-      advance(65_000)
-    }
-
-    expect(maps.chats.size).toBe(0)
-    expect(maps.chatRunningSubagents.size).toBe(0)
-    expect(maps.baseTurnSeqs.size).toBe(0)
-    // The dedup maps may keep at most one straggler from the final turn.
-    expect(maps.seenEnqueueMsgIds.size).toBeLessThanOrEqual(1)
-    expect(maps.pendingSyncEchoes.size).toBeLessThanOrEqual(1)
-    // editTimestamps is per-turnKey; cleared on completeTurnFully.
-    expect(maps.editTimestamps.size).toBeLessThanOrEqual(1)
-  })
-
-  it('with a long-lived bg sub-agent across cycles, only the originating turnKey persists', () => {
-    const { driver, advance } = makeHarness({
-      heartbeatMs: 5_000,
-      promoteAfterMs: 999_999,
-    })
-    const maps = driver._debugGetMaps!()
-
-    // One bg sub-agent that NEVER finishes; 50 surrounding turns close cleanly.
-    driver.ingest(enqueue('chatA'), null)
-    driver.ingest(
-      {
-        kind: 'tool_use', toolName: 'Agent', toolUseId: 'tu1',
-        input: { prompt: 'forever-bg', run_in_background: true },
-      },
-      'chatA',
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saBG', firstPromptText: 'forever-bg' }, 'chatA')
-    driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, 'chatA')
-    driver.recordOutboundDelivered('chatA')
-    driver.ingest({ kind: 'turn_end', durationMs: 50 }, 'chatA')
-
-    for (let i = 0; i < 50; i++) {
-      driver.ingest(enqueue('chatA'), null)
-      driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, 'chatA')
-      driver.recordOutboundDelivered('chatA')
-      driver.ingest({ kind: 'turn_end', durationMs: 50 }, 'chatA')
-      advance(65_000)
-    }
-
-    // After 50 clean surrounding turns each followed by `advance(65_000)`
-    // (well past TTL + eviction throttle), every chatState — including
-    // the originating one whose bg sub-agent never finished — has been
-    // rolled forward and evicted. Empty is the correct steady state, not
-    // the "≤ 2" the original PR shipped. What this test really proves
-    // is that `chats` doesn't grow with cycle count.
-    expect(maps.chats.size).toBe(0)
-    expect(maps.baseTurnSeqs.size).toBeLessThanOrEqual(1)
-  })
-})

package/telegram-plugin/tests/progress-card-pin-failure-paths.test.ts

@@ -1,139 +0,0 @@
-/**
- * PR-C2 — pin/unpin failure paths beyond what PR-A covered.
- *
- * PR-A added: pin reject + sidecar still cleared (`firePin API rejection
- * deletes from pinned map and clears sidecar`), unpin reject + sidecar
- * still cleared.
- *
- * This file extends with the consistency-of-internal-state angle:
- *
- *   1. After a pin REJECTION, the manager's `pinned` map must NOT
- *      retain the failed message id — otherwise a later completeTurn
- *      would issue an unpin for a message that was never actually
- *      pinned, and pinnedTurnKeys() would lie.
- *
- *   2. After an unpin REJECTION, the (turnKey, agentId) must still be
- *      considered "unpinned" so a duplicate completeTurn doesn't
- *      double-fire deps.unpin (the .finally branch only clears the
- *      sidecar; the in-memory `pinned`/`unpinned` bookkeeping is what
- *      guards against duplicate API calls).
- *
- * fails when: firePin's catch branch forgets to delete the composite
- * from the `pinned` map (so pinnedTurnKeys grows ghost entries) OR
- * doUnpin's `unpinned.add(key)` is moved to inside the success branch
- * of the unpin promise (so a reject leaves unpinned set un-flipped and
- * a second completeTurn double-unpins).
- */
-import { describe, it, expect } from 'vitest'
-import { createPinManager, type TimerHandle } from '../progress-card-pin-manager.js'
-import { errors } from './fake-bot-api.js'
-
-interface T { fn: () => void; cancelled: boolean; fired: boolean }
-function makeHarness() {
-  const timers: T[] = []
-  const sidecar: Array<{ chatId: string; messageId: number }> = []
-  let pinCalls = 0
-  let unpinCalls = 0
-
-  let pinReject: Error | null = null
-  let unpinReject: Error | null = null
-
-  const mgr = createPinManager({
-    pin: async (_chatId, _messageId) => {
-      pinCalls++
-      if (pinReject) {
-        const e = pinReject
-        pinReject = null
-        throw e
-      }
-      return true
-    },
-    unpin: async (_chatId, _messageId) => {
-      unpinCalls++
-      if (unpinReject) {
-        const e = unpinReject
-        unpinReject = null
-        throw e
-      }
-      return true
-    },
-    addPin: (e) => { sidecar.push({ chatId: e.chatId, messageId: e.messageId }) },
-    removePin: (chatId, messageId) => {
-      const i = sidecar.findIndex((s) => s.chatId === chatId && s.messageId === messageId)
-      if (i >= 0) sidecar.splice(i, 1)
-    },
-    log: () => {},
-    now: () => 1000,
-    scheduleTimer: (fn): TimerHandle => {
-      const t: T = { fn, cancelled: false, fired: false }
-      timers.push(t)
-      return { cancel: () => { t.cancelled = true } }
-    },
-  })
-
-  return {
-    mgr,
-    sidecar,
-    fireTimers: () => {
-      for (const t of [...timers]) {
-        if (t.cancelled || t.fired) continue
-        t.fired = true
-        t.fn()
-      }
-    },
-    setPinReject: (e: Error) => { pinReject = e },
-    setUnpinReject: (e: Error) => { unpinReject = e },
-    counts: () => ({ pin: pinCalls, unpin: unpinCalls }),
-  }
-}
-
-describe('PR-C2: pin/unpin failure → internal map consistency', () => {
-  it('pin REJECT: pinned map drops the composite so pinnedTurnKeys() does not lie', async () => {
-    const h = makeHarness()
-    h.setPinReject(errors.forbidden())
-    h.mgr.considerPin({
-      chatId: 'c', threadId: '0', turnKey: 'c:0:1', messageId: 500, isFirstEmit: true,
-    })
-    h.fireTimers()
-    await h.mgr.drainInFlight()
-
-    // Sidecar cleared by firePin's catch branch (already covered in PR-A).
-    expect(h.sidecar).toEqual([])
-    // CRITICAL extension: the in-memory pinned map must not still claim
-    // turnKey c:0:1 was successfully pinned.
-    expect(h.mgr.pinnedTurnKeys()).toEqual([])
-    expect(h.mgr.pinnedMessageId('c:0:1')).toBeUndefined()
-
-    // And a follow-up completeTurn must NOT issue any unpin call —
-    // there's nothing to unpin.
-    h.mgr.completeTurn({ chatId: 'c', turnKey: 'c:0:1' })
-    await h.mgr.drainInFlight()
-    expect(h.counts().unpin).toBe(0)
-  })
-
-  it('unpin REJECT: duplicate completeTurn does NOT double-fire deps.unpin', async () => {
-    const h = makeHarness()
-    h.setUnpinReject(errors.badRequest('chat not found', 'unpinChatMessage'))
-
-    h.mgr.considerPin({
-      chatId: 'c', threadId: '0', turnKey: 'c:0:1', messageId: 500, isFirstEmit: true,
-    })
-    h.fireTimers()
-    await h.mgr.drainInFlight()
-    expect(h.counts().pin).toBe(1)
-    expect(h.mgr.pinnedTurnKeys()).toEqual(['c:0:1'])
-
-    // First completeTurn — unpin attempted, rejects.
-    h.mgr.completeTurn({ chatId: 'c', turnKey: 'c:0:1' })
-    await h.mgr.drainInFlight()
-    expect(h.counts().unpin).toBe(1)
-
-    // Second completeTurn (e.g. forceCompleteTurn racing with turn_end).
-    // The in-memory bookkeeping must guard against re-firing unpin.
-    h.mgr.completeTurn({ chatId: 'c', turnKey: 'c:0:1' })
-    await h.mgr.drainInFlight()
-    expect(h.counts().unpin).toBe(1)
-    // pinned map empty (doUnpin deletes regardless of unpin promise outcome)
-    expect(h.mgr.pinnedTurnKeys()).toEqual([])
-  })
-})