Flush event cache when ai prepare event is expired

Author: Sidnioulz

code/core/src/telemetry/ai-prepare-utils.ts

@@ -1,4 +1,4 @@
-import { getAiPreparePending } from './event-cache.ts';
+import { flushAiPreparePending, getAiPreparePending } from './event-cache.ts';
 import { SESSION_TIMEOUT } from './session-id.ts';
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
@@ -107,7 +107,8 @@ export async function collectAiPrepareEvidence(
     // Gate 4: Is it within the session window?
     const timeSincePrepare = Date.now() - pending.timestamp;
     if (timeSincePrepare > SESSION_TIMEOUT) {
-      // TODO: purge aiPreparePending
+      // Session expired, clean up pending record.
+      await flushAiPreparePending();
       return;
     }
 

code/core/src/telemetry/event-cache.test.ts

@@ -4,7 +4,13 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { cache } from 'storybook/internal/common';
 
 import type { CacheEntry } from './event-cache.ts';
-import { getLastEvents, getPrecedingUpgrade, set } from './event-cache.ts';
+import {
+  flushAiPreparePending,
+  getAiPreparePending,
+  getLastEvents,
+  getPrecedingUpgrade,
+  set,
+} from './event-cache.ts';
 import type { TelemetryEvent } from './types.ts';
 
 vi.mock('storybook/internal/common', { spy: true });
@@ -347,4 +353,40 @@ describe('event-cache', () => {
       expect(result).toEqual(afterDev);
     });
   });
+
+  describe('ai-prepare pending cache', () => {
+    let cacheGetMock: MockInstance;
+    let cacheRemoveMock: MockInstance;
+
+    beforeEach(() => {
+      vi.clearAllMocks();
+      cacheGetMock = vi.mocked(cache.get);
+      cacheRemoveMock = vi.mocked(cache.remove);
+    });
+
+    it('returns cached ai-prepare pending record when present', async () => {
+      const pending = {
+        timestamp: 123,
+        sessionId: 'session-1',
+        configDir: '/tmp/.storybook',
+        previewPath: '/tmp/.storybook/preview.ts',
+        previewHash: 'abc123',
+      };
+
+      cacheGetMock.mockResolvedValueOnce(pending);
+
+      await expect(getAiPreparePending()).resolves.toEqual(pending);
+      expect(cacheGetMock).toHaveBeenCalledWith('ai-prepare-pending');
+    });
+
+    it('removes the cached ai-prepare pending record and returns undefined', async () => {
+      cacheRemoveMock.mockResolvedValueOnce(undefined);
+      cacheGetMock.mockResolvedValueOnce(undefined);
+
+      await expect(flushAiPreparePending()).resolves.toBeUndefined();
+      expect(cacheRemoveMock).toHaveBeenCalledWith('ai-prepare-pending');
+      await expect(getAiPreparePending()).resolves.toBeUndefined();
+      expect(cacheGetMock).toHaveBeenCalledWith('ai-prepare-pending');
+    });
+  });
 });

code/core/src/telemetry/event-cache.ts

@@ -99,3 +99,10 @@ export const getAiPreparePending = async (): Promise<AiPreparePendingRecord | un
   await processingPromise;
   return (await cache.get('ai-prepare-pending')) ?? undefined;
 };
+
+export const flushAiPreparePending = async (): Promise<undefined> => {
+  // Wait for any pending set operations to complete before removing
+  await processingPromise;
+  await cache.remove('ai-prepare-pending');
+  return undefined;
+};