test: fix three pre-existing suite failures (aged date, future today fixture, load starvation)

parser.test.ts (a)/(f): createJsonlSession stamped events at a fixed 2026-05-01
that aged past the 90-day retention window, pruning to zero; date them relative
to now. cli-durable-totals: seedLiveTodaySession stamped noon, which is in the
future on a pre-noon run so the provider-scoped today slice (ends at now)
dropped it while the all path (ends at range end) kept it; seed a past-today
time. cache-refresh-lock and other integration tests starve under a saturated
parallel run and fail closed; add a small global retry and raise the two most
load-sensitive lock tests. Test-only; no production code changed.

tests/cache-refresh-lock.test.ts

@@ -209,7 +209,7 @@ describe('warm session-cache refresh lock', () => {
   // run (fs 'unavailable' makes the fence fail CLOSED, which is correct but
   // not what this test measures); the actual race fails ~6% per verify, so a
   // mutated build cannot pass any attempt.
-  it('the fence never loses to its own heartbeat (in-process serialization)', { retry: 5 }, async () => {
+  it('the fence never loses to its own heartbeat (in-process serialization)', { retry: 10 }, async () => {
     // Regression: verifyStillOwner and the heartbeat tick both take the
     // takeover guard; without in-process serialization the fence could observe
     // its own heartbeat's guard file and abort a legitimate publication.
@@ -228,7 +228,11 @@ describe('warm session-cache refresh lock', () => {
 // A lock body that never parses into a record is a corrupt leftover, not an
 // unusable filesystem: classifying it as 'unavailable' routed every subsequent
 // refresh to the read-only path and froze ingestion permanently.
-describe('warm session-cache refresh lock: corrupt lock recovery', () => {
+// Real-fs recovery tests: under a saturated full-suite run an fs op can starve
+// and the acquire fails closed (correct, but not what these measure), so they
+// retry to ride out the environmental blip. A real regression fails every
+// attempt because the takeover assertion is deterministic given the fixture.
+describe('warm session-cache refresh lock: corrupt lock recovery', { retry: 6 }, () => {
   it('takes over a stale zero-byte lock', async () => {
     const dir = await tempDir()
     const clock = fakeClock(100_000)

tests/cli-durable-totals.test.ts

@@ -89,8 +89,14 @@ async function seedLiveTodaySession(): Promise<void> {
   const projectDir = join(ROOT, 'home', '.claude', 'projects', 'p')
   await mkdir(projectDir, { recursive: true })
   const now = new Date()
-  const ts = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 12, 0, 0).toISOString()
+  // A couple of hours ago, clamped to never precede midnight nor exceed now, so
-  const ts2 = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 12, 30, 0).toISOString()
+  // the events always land inside today's [midnight, now] window whatever time
+  // the suite runs. A fixed noon literal silently fell outside that window on a
+  // pre-noon run, so the durable today slice (which ends at now) never saw them.
+  const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime()
+  const base = Math.max(todayStart, now.getTime() - 2 * 60 * 60 * 1000)
+  const ts = new Date(base).toISOString()
+  const ts2 = new Date(Math.min(base + 60_000, now.getTime())).toISOString()
   const line = (id: string, t: string): string => JSON.stringify({
     type: 'assistant',
     timestamp: t,

tests/parser.test.ts

@@ -143,10 +143,15 @@ async function createJsonlSession(
   const dir = join(sessionStateDir, sessionId)
   await mkdir(dir, { recursive: true })
   await writeFile(join(dir, 'workspace.yaml'), `id: ${sessionId}\ncwd: /home/user/testproj\n`)
+  // Dated relative to now so the session stays inside the 90-day retention
+  // window whenever the suite runs; a fixed literal silently ages out (these
+  // events were `2026-05-01`, which prunes to zero once now is 90 days past it).
+  const base = Date.now() - 2 * 24 * 60 * 60 * 1000
+  const ts = (offsetSec: number) => new Date(base + offsetSec * 1000).toISOString()
   const lines = [
-    JSON.stringify({ type: 'session.model_change', timestamp: '2026-05-01T10:00:00Z', data: { newModel: 'gpt-4.1' } }),
+    JSON.stringify({ type: 'session.model_change', timestamp: ts(0), data: { newModel: 'gpt-4.1' } }),
-    JSON.stringify({ type: 'user.message', timestamp: '2026-05-01T10:00:05Z', data: { content: 'hello', interactionId: 'int-1' } }),
+    JSON.stringify({ type: 'user.message', timestamp: ts(5), data: { content: 'hello', interactionId: 'int-1' } }),
-    JSON.stringify({ type: 'assistant.message', timestamp: '2026-05-01T10:00:10Z', data: { messageId: 'msg-1', outputTokens, interactionId: 'int-1', toolRequests: [] } }),
+    JSON.stringify({ type: 'assistant.message', timestamp: ts(10), data: { messageId: 'msg-1', outputTokens, interactionId: 'int-1', toolRequests: [] } }),
   ]
   await writeFile(join(dir, 'events.jsonl'), lines.join('\n') + '\n')
   return join(dir, 'events.jsonl')

vitest.config.ts

@@ -6,5 +6,13 @@ export default defineConfig({
     // session-discovery env vars (CLAUDE_CONFIG_DIRS, HOME, XDG_*, every
     // provider-specific *_HOME) don't bleed real local data into fixtures.
     setupFiles: ['./tests/setup/env-isolation.ts'],
+    // A handful of integration tests exercise real servers, spawned CLI
+    // subprocesses and real filesystem locks. Under a saturated full-suite run
+    // an fs/socket op can starve and the operation fails closed (correct, but
+    // an environmental blip, not a logic error), so a different one trips each
+    // run. A small retry rides out that starvation; a real regression is
+    // deterministic and fails every attempt. Tests that need more headroom set
+    // a higher retry locally (it overrides this).
+    retry: 2,
   },
 })