fix(session-storage): bound getSessionMessages cache to prevent unbounded growth

`getSessionMessages` was implemented via `lodash memoize`, which has no
size cap. Each unique sessionId adds a `Promise<Set<UUID>>` entry that
is only cleared by `clearSessionMessagesCache()` — and that call is
only made from `postCompactCleanup`, which fires once per compaction.

In long-running daemon / swarm sessions that spawn many agents (each
with its own transcript), the cache grows unbounded for the process
lifetime. Per-entry Sets are MUCH larger than the file-path strings
the adjacent `existingSessionFiles` cache stores, so the leak is more
severe than the one fixed for that cache at `sessionStorage.ts:535`.

The fix mirrors the existing `existingSessionFiles` pattern: replace
lodash `memoize` with a `Map<UUID, Promise<Set<UUID>>>` and evict the
oldest entry (FIFO via Map insertion order) when at
`MAX_CACHED_SESSION_FILES` capacity. Re-uses the same constant for
consistency.

Concretely:
- `sessionStorage.ts`: refactor `getSessionMessages` to be a regular
  `async function` backed by a module-level `Map`, with FIFO eviction
  at `MAX_CACHED_SESSION_FILES`. Export `getSessionMessagesCache()` so
  `getLastSessionLog`'s priming logic (and tests) can interact with the
  underlying Map directly. Export `getSessionMessages` itself with a
  `@internal`-style comment noting it's not part of the public API
  (callers should keep using `doesMessageExistInSession`).
- `src/utils/__tests__/sessionStorage.test.ts` (new): 7 tests covering
  cache identity, clear behavior, concurrent-call dedup, bounded size
  after many distinct sessionIds, FIFO eviction order, and refill
  after clear. Uses real temp directory + `CLAUDE_CONFIG_DIR` env to
  keep tests hermetic — no `mock.module` pollution.

Verified on Windows 11 + Bun 1.3.14:
- `bun run precheck`: 5899/5900 pass (the 1 fail is a pre-existing flaky
  `toolEventObserver` test that times out on Windows runners, unrelated
  to this change)
- 7/7 new tests pass
- No regressions in other test files

Co-Authored-By: Claude <noreply@anthropic.com>

Author: hongye

src/utils/__tests__/sessionStorage.test.ts

@@ -0,0 +1,151 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+const MAX_CACHED_ENTRIES = 200 // mirrors MAX_CACHED_SESSION_FILES in sessionStorage.ts
+
+const {
+  getSessionMessages,
+  getSessionMessagesCache,
+  clearSessionMessagesCache,
+} = await import('../sessionStorage.js')
+
+function asUuid(s: string): any {
+  return s as unknown as any
+}
+
+let tempDir: string
+let originalConfigDir: string | undefined
+
+beforeEach(() => {
+  tempDir = join(
+    tmpdir(),
+    `claude-session-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  mkdirSync(tempDir, { recursive: true })
+  // `getProjectsDir()` returns `${CLAUDE_CONFIG_DIR}/projects`, and
+  // loadSessionFile reads from `${getProjectsDir()}/${sessionId}.jsonl`.
+  // Pre-create the projects subdir so writeFileSync doesn't fail.
+  mkdirSync(join(tempDir, 'projects'), { recursive: true })
+  // Pin session-file lookups to a temp dir via CLAUDE_CONFIG_DIR.
+  // Restoring in afterEach keeps tests hermetic.
+  originalConfigDir = process.env.CLAUDE_CONFIG_DIR
+  process.env.CLAUDE_CONFIG_DIR = tempDir
+})
+
+afterEach(() => {
+  clearSessionMessagesCache()
+  if (originalConfigDir === undefined) {
+    delete process.env.CLAUDE_CONFIG_DIR
+  } else {
+    process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+  }
+  if (tempDir && existsSync(tempDir)) {
+    rmSync(tempDir, { recursive: true, force: true })
+  }
+})
+
+function sessionFilePath(sessionId: string): string {
+  // Mirror sessionStorage.ts's path computation:
+  //   getSessionProjectDir() ?? getProjectDir(getOriginalCwd())
+  // With CLAUDE_CONFIG_DIR=tempDir and getSessionProjectDir() returning
+  // null in tests, files live at `${tempDir}/projects/${sessionId}.jsonl`.
+  return join(tempDir, 'projects', `${sessionId}.jsonl`)
+}
+
+describe('getSessionMessagesCache', () => {
+  test('returns the same Map instance across calls', () => {
+    // Cache identity must be stable — `getLastSessionLog` uses
+    // `getSessionMessagesCache()` directly to prime entries, so a
+    // different instance each call would break that priming.
+    expect(getSessionMessagesCache()).toBe(getSessionMessagesCache())
+  })
+
+  test('clearSessionMessagesCache empties a populated cache', async () => {
+    const cache = getSessionMessagesCache()
+    writeFileSync(sessionFilePath('id-1'), '')
+    writeFileSync(sessionFilePath('id-2'), '')
+    await getSessionMessages(asUuid('id-1'))
+    await getSessionMessages(asUuid('id-2'))
+    expect(cache.size).toBeGreaterThan(0)
+
+    clearSessionMessagesCache()
+    expect(cache.size).toBe(0)
+  })
+
+  test('clearSessionMessagesCache is a no-op on empty cache', () => {
+    const cache = getSessionMessagesCache()
+    expect(cache.size).toBe(0)
+    clearSessionMessagesCache()
+    expect(cache.size).toBe(0)
+  })
+
+  test('getSessionMessages dedups concurrent calls for the same sessionId', async () => {
+    const cache = getSessionMessagesCache()
+    const id = asUuid('same-id')
+    writeFileSync(sessionFilePath('same-id'), '')
+    const [a, b, c] = await Promise.all([
+      getSessionMessages(id),
+      getSessionMessages(id),
+      getSessionMessages(id),
+    ])
+    expect(a).toBe(b)
+    expect(b).toBe(c)
+    expect(cache.size).toBe(1)
+  })
+})
+
+describe('getSessionMessages bounded cache (memory leak fix)', () => {
+  test('cache size stays at MAX_CACHED_ENTRIES after many distinct sessionIds', async () => {
+    // Bounded cache — calling getSessionMessages with N distinct
+    // sessionIds must NOT grow the cache beyond MAX_CACHED_ENTRIES.
+    // Pre-fix: lodash memoize grew unbounded. Post-fix: Map-based
+    // cache evicts oldest entry when at capacity.
+    const cache = getSessionMessagesCache()
+    const total = MAX_CACHED_ENTRIES * 3 // 600 distinct sessionIds
+    for (let i = 0; i < total; i++) {
+      writeFileSync(sessionFilePath(`id-${i}`), '')
+      await getSessionMessages(asUuid(`id-${i}`))
+    }
+    expect(cache.size).toBe(MAX_CACHED_ENTRIES)
+  })
+
+  test('FIFO eviction: oldest entry is removed first', async () => {
+    // Fill cache to MAX with sequential ids. The first inserted
+    // (`oldest`) should be evicted on the (MAX+1)th insertion.
+    const cache = getSessionMessagesCache()
+    const oldestId = asUuid('id-0')
+    writeFileSync(sessionFilePath('id-0'), '')
+    await getSessionMessages(oldestId)
+    for (let i = 1; i < MAX_CACHED_ENTRIES; i++) {
+      writeFileSync(sessionFilePath(`id-${i}`), '')
+      await getSessionMessages(asUuid(`id-${i}`))
+    }
+    expect(cache.size).toBe(MAX_CACHED_ENTRIES)
+    expect(cache.has(oldestId)).toBe(true)
+
+    writeFileSync(sessionFilePath('id-overflow'), '')
+    await getSessionMessages(asUuid('id-overflow'))
+    expect(cache.size).toBe(MAX_CACHED_ENTRIES)
+    expect(cache.has(oldestId)).toBe(false)
+  })
+
+  test('cleared cache can be refilled without leaking entries', async () => {
+    const cache = getSessionMessagesCache()
+    for (let i = 0; i < MAX_CACHED_ENTRIES; i++) {
+      writeFileSync(sessionFilePath(`id-${i}`), '')
+      await getSessionMessages(asUuid(`id-${i}`))
+    }
+    expect(cache.size).toBe(MAX_CACHED_ENTRIES)
+
+    clearSessionMessagesCache()
+    expect(cache.size).toBe(0)
+
+    for (let i = 0; i < MAX_CACHED_ENTRIES + 5; i++) {
+      writeFileSync(sessionFilePath(`refill-${i}`), '')
+      await getSessionMessages(asUuid(`refill-${i}`))
+    }
+    expect(cache.size).toBe(MAX_CACHED_ENTRIES)
+  })
+})

src/utils/sessionStorage.ts

@@ -3941,24 +3941,55 @@ async function loadSessionFile(sessionId: UUID): Promise<{
   return loadTranscriptFile(sessionFile)
 }
 
+/**
+ * Bounded cache for {@link getSessionMessages}. Bounded at
+ * {@link MAX_CACHED_SESSION_FILES} to prevent unbounded Map growth in
+ * long-running daemon / swarm sessions that spawn many agents — mirrors
+ * the existingSessionFiles pattern above. Entries are evicted in FIFO
+ * order via `Map` insertion order.
+ */
+const sessionMessagesCache = new Map<UUID, Promise<Set<UUID>>>()
+
 /**
  * Gets message UUIDs for a specific session without loading all sessions.
- * Memoized to avoid re-reading the same session file multiple times.
+ * Cached (bounded) to avoid re-reading the same session file multiple
+ * times. Concurrent calls for the same `sessionId` share one in-flight
+ * load promise.
+ *
+ * Exported so tests can verify cache eviction behavior directly; not
+ * intended as a public API — prefer {@link doesMessageExistInSession}.
  */
-const getSessionMessages = memoize(
-  async (sessionId: UUID): Promise<Set<UUID>> => {
+export async function getSessionMessages(sessionId: UUID): Promise<Set<UUID>> {
+  const existing = sessionMessagesCache.get(sessionId)
+  if (existing !== undefined) {
+    return existing
+  }
+  // Evict oldest entry when at capacity so the Map stays bounded.
+  if (sessionMessagesCache.size >= MAX_CACHED_SESSION_FILES) {
+    const oldestKey = sessionMessagesCache.keys().next().value
+    if (oldestKey !== undefined) {
+      sessionMessagesCache.delete(oldestKey)
+    }
+  }
+  const promise = (async () => {
     const { messages } = await loadSessionFile(sessionId)
     return new Set(messages.keys())
-  },
-  (sessionId: UUID) => sessionId,
-)
+  })()
+  sessionMessagesCache.set(sessionId, promise)
+  return promise
+}
+
+/** Underlying cache for direct manipulation (priming, clearing, tests). */
+export function getSessionMessagesCache(): Map<UUID, Promise<Set<UUID>>> {
+  return sessionMessagesCache
+}
 
 /**
- * Clear the memoized session messages cache.
+ * Clear the cached session messages.
  * Call after compaction when old message UUIDs are no longer valid.
  */
 export function clearSessionMessagesCache(): void {
-  getSessionMessages.cache.clear?.()
+  sessionMessagesCache.clear()
 }
 
 /**
@@ -3996,11 +4027,9 @@ export async function getLastSessionLog(
   // Guard: only prime if cache is empty. Mid-session callers (e.g. IssueFeedback)
   // may call getLastSessionLog on the current session — overwriting a live cache
   // with a stale disk snapshot would lose unflushed UUIDs and break dedup.
-  if (!getSessionMessages.cache.has(sessionId)) {
-    getSessionMessages.cache.set(
-      sessionId,
-      Promise.resolve(new Set(messages.keys())),
-    )
+  const messagesCache = getSessionMessagesCache()
+  if (!messagesCache.has(sessionId)) {
+    messagesCache.set(sessionId, Promise.resolve(new Set(messages.keys())))
   }
 
   // Find the most recent non-sidechain message