@machina.ai/cell-cli-core 1.38.1-rc2 → 1.40.1-rc2

package/dist/src/services/chatRecordingService.test.js

@@ -4,16 +4,46 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { expect, it, describe, vi, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
+import * as fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { ChatRecordingService, } from './chatRecordingService.js';
+vi.mock('node:fs', async (importOriginal) => {
+    const actual = await importOriginal();
+    const fsModule = {
+        ...actual,
+        mkdirSync: vi.fn(actual.mkdirSync),
+        appendFileSync: vi.fn(actual.appendFileSync),
+        writeFileSync: vi.fn(actual.writeFileSync),
+        readFileSync: vi.fn(actual.readFileSync),
+        unlinkSync: vi.fn(actual.unlinkSync),
+        existsSync: vi.fn(actual.existsSync),
+        readdirSync: vi.fn(actual.readdirSync),
+        promises: {
+            ...actual.promises,
+            stat: vi.fn(actual.promises.stat),
+            readFile: vi.fn(actual.promises.readFile),
+            unlink: vi.fn(actual.promises.unlink),
+            readdir: vi.fn(actual.promises.readdir),
+            open: vi.fn(actual.promises.open),
+            rm: vi.fn(actual.promises.rm),
+            mkdir: vi.fn(actual.promises.mkdir),
+            writeFile: vi.fn(actual.promises.writeFile),
+        },
+    };
+    return {
+        ...fsModule,
+        default: fsModule,
+    };
+});
+import { ChatRecordingService, loadConversationRecord, } from './chatRecordingService.js';
 import { CoreToolCallStatus } from '../scheduler/types.js';
 import { getProjectHash } from '../utils/paths.js';
 vi.mock('../utils/paths.js');
-vi.mock('node:crypto', () => {
+vi.mock('node:crypto', async (importOriginal) => {
+    const actual = await importOriginal();
     let count = 0;
     return {
+        ...actual,
         randomUUID: vi.fn(() => `test-uuid-${count++}`),
         createHash: vi.fn(() => ({
             update: vi.fn(() => ({
@@ -26,6 +56,9 @@ describe('ChatRecordingService', () => {
     let chatRecordingService;
     let mockConfig;
     let testTempDir;
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
     beforeEach(async () => {
         testTempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'chat-recording-test-'));
         mockConfig = {
@@ -70,8 +103,8 @@ describe('ChatRecordingService', () => {
         }
     });
     describe('initialize', () => {
-        it('should create a new session if none is provided', () => {
-            chatRecordingService.initialize();
+        it('should create a new session if none is provided', async () => {
+            await chatRecordingService.initialize();
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'ping',
@@ -81,27 +114,27 @@ describe('ChatRecordingService', () => {
             expect(fs.existsSync(chatsDir)).toBe(true);
             const files = fs.readdirSync(chatsDir);
             expect(files.length).toBeGreaterThan(0);
-            expect(files[0]).toMatch(/^session-.*-test-ses\.json$/);
+            expect(files[0]).toMatch(/^session-.*-test-ses\.jsonl$/);
         });
-        it('should include the conversation kind when specified', () => {
-            chatRecordingService.initialize(undefined, 'subagent');
+        it('should include the conversation kind when specified', async () => {
+            await chatRecordingService.initialize(undefined, 'subagent');
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'ping',
                 model: 'm',
             });
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.kind).toBe('subagent');
         });
-        it('should create a subdirectory for subagents if parentSessionId is present', () => {
+        it('should create a subdirectory for subagents if parentSessionId is present', async () => {
             const parentSessionId = 'test-parent-uuid';
             Object.defineProperty(mockConfig, 'parentSessionId', {
                 value: parentSessionId,
                 writable: true,
                 configurable: true,
             });
-            chatRecordingService.initialize(undefined, 'subagent');
+            await chatRecordingService.initialize(undefined, 'subagent');
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'ping',
@@ -112,51 +145,56 @@ describe('ChatRecordingService', () => {
             expect(fs.existsSync(subagentDir)).toBe(true);
             const files = fs.readdirSync(subagentDir);
             expect(files.length).toBeGreaterThan(0);
-            expect(files[0]).toBe('test-session-id.json');
+            expect(files[0]).toBe('test-session-id.jsonl');
         });
-        it('should inherit workspace directories for subagents during initialization', () => {
+        it('should inherit workspace directories for subagents during initialization', async () => {
             const mockDirectories = ['/project/dir1', '/project/dir2'];
             vi.mocked(mockConfig.getWorkspaceContext).mockReturnValue({
                 getDirectories: vi.fn().mockReturnValue(mockDirectories),
             });
             // Initialize as a subagent
-            chatRecordingService.initialize(undefined, 'subagent');
-            // Recording a message triggers the disk write (deferred until then)
+            await chatRecordingService.initialize(undefined, 'subagent');
+            // Recording a message triggers the disk write
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'ping',
                 model: 'm',
             });
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.kind).toBe('subagent');
             expect(conversation.directories).toEqual(mockDirectories);
         });
-        it('should resume from an existing session if provided', () => {
+        it('should resume from an existing session if provided', async () => {
             const chatsDir = path.join(testTempDir, 'chats');
             fs.mkdirSync(chatsDir, { recursive: true });
-            const sessionFile = path.join(chatsDir, 'session.json');
+            const sessionFile = path.join(chatsDir, 'session.jsonl');
             const initialData = {
                 sessionId: 'old-session-id',
                 projectHash: 'test-project-hash',
                 messages: [],
             };
-            fs.writeFileSync(sessionFile, JSON.stringify(initialData));
-            chatRecordingService.initialize({
+            fs.writeFileSync(sessionFile, JSON.stringify({ ...initialData, messages: undefined }) +
+                '\n' +
+                (initialData.messages || [])
+                    .map((m) => JSON.stringify(m))
+                    .join('\n') +
+                '\n');
+            await chatRecordingService.initialize({
                 filePath: sessionFile,
                 conversation: {
                     sessionId: 'old-session-id',
                 },
             });
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.sessionId).toBe('old-session-id');
         });
     });
     describe('recordMessage', () => {
-        beforeEach(() => {
-            chatRecordingService.initialize();
+        beforeEach(async () => {
+            await chatRecordingService.initialize();
         });
-        it('should record a new message', () => {
+        it('should record a new message', async () => {
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'Hello',
@@ -164,27 +202,27 @@ describe('ChatRecordingService', () => {
                 model: 'gemini-pro',
             });
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.messages).toHaveLength(1);
             expect(conversation.messages[0].content).toBe('Hello');
             expect(conversation.messages[0].displayContent).toBe('User Hello');
             expect(conversation.messages[0].type).toBe('user');
         });
-        it('should create separate messages when recording multiple messages', () => {
+        it('should create separate messages when recording multiple messages', async () => {
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'World',
                 model: 'gemini-pro',
             });
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.messages).toHaveLength(1);
             expect(conversation.messages[0].content).toBe('World');
         });
     });
     describe('recordThought', () => {
-        it('should queue a thought', () => {
-            chatRecordingService.initialize();
+        it('should queue a thought', async () => {
+            await chatRecordingService.initialize();
             chatRecordingService.recordThought({
                 subject: 'Thinking',
                 description: 'Thinking...',
@@ -196,10 +234,10 @@ describe('ChatRecordingService', () => {
         });
     });
     describe('recordMessageTokens', () => {
-        beforeEach(() => {
-            chatRecordingService.initialize();
+        beforeEach(async () => {
+            await chatRecordingService.initialize();
         });
-        it('should update the last message with token info', () => {
+        it('should update the last message with token info', async () => {
             chatRecordingService.recordMessage({
                 type: 'gemini',
                 content: 'Response',
@@ -212,7 +250,7 @@ describe('ChatRecordingService', () => {
                 cachedContentTokenCount: 0,
             });
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             const geminiMsg = conversation.messages[0];
             expect(geminiMsg.tokens).toEqual({
                 input: 1,
@@ -223,7 +261,7 @@ describe('ChatRecordingService', () => {
                 tool: 0,
             });
         });
-        it('should queue token info if the last message already has tokens', () => {
+        it('should queue token info if the last message already has tokens', async () => {
             chatRecordingService.recordMessage({
                 type: 'gemini',
                 content: 'Response',
@@ -251,10 +289,10 @@ describe('ChatRecordingService', () => {
                 tool: 0,
             });
         });
-        it('should not write to disk when queuing tokens (no last gemini message)', () => {
-            const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync');
+        it('should not write to disk when queuing tokens (no last gemini message)', async () => {
+            const appendFileSyncSpy = vi.mocked(fs.appendFileSync);
             // Clear spy call count after initialize writes the initial file
-            writeFileSyncSpy.mockClear();
+            appendFileSyncSpy.mockClear();
             // No gemini message recorded yet, so tokens should only be queued
             chatRecordingService.recordMessageTokens({
                 promptTokenCount: 5,
@@ -263,7 +301,7 @@ describe('ChatRecordingService', () => {
                 cachedContentTokenCount: 0,
             });
             // writeFileSync should NOT have been called since we only queued
-            expect(writeFileSyncSpy).not.toHaveBeenCalled();
+            expect(appendFileSyncSpy).not.toHaveBeenCalled();
             // @ts-expect-error private property
             expect(chatRecordingService.queuedTokens).toEqual({
                 input: 5,
@@ -273,9 +311,8 @@ describe('ChatRecordingService', () => {
                 thoughts: 0,
                 tool: 0,
             });
-            writeFileSyncSpy.mockRestore();
         });
-        it('should not write to disk when queuing tokens (last message already has tokens)', () => {
+        it('should not write to disk when queuing tokens (last message already has tokens)', async () => {
             chatRecordingService.recordMessage({
                 type: 'gemini',
                 content: 'Response',
@@ -288,8 +325,8 @@ describe('ChatRecordingService', () => {
                 totalTokenCount: 2,
                 cachedContentTokenCount: 0,
             });
-            const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync');
-            writeFileSyncSpy.mockClear();
+            const appendFileSyncSpy = vi.mocked(fs.appendFileSync);
+            appendFileSyncSpy.mockClear();
             // Second call should only queue, NOT write to disk
             chatRecordingService.recordMessageTokens({
                 promptTokenCount: 2,
@@ -297,16 +334,15 @@ describe('ChatRecordingService', () => {
                 totalTokenCount: 4,
                 cachedContentTokenCount: 0,
             });
-            expect(writeFileSyncSpy).not.toHaveBeenCalled();
-            writeFileSyncSpy.mockRestore();
+            expect(appendFileSyncSpy).not.toHaveBeenCalled();
         });
-        it('should use in-memory cache and not re-read from disk on subsequent operations', () => {
+        it('should use in-memory cache and not re-read from disk on subsequent operations', async () => {
             chatRecordingService.recordMessage({
                 type: 'gemini',
                 content: 'Response',
                 model: 'gemini-pro',
             });
-            const readFileSyncSpy = vi.spyOn(fs, 'readFileSync');
+            const readFileSyncSpy = vi.mocked(fs.readFileSync);
             readFileSyncSpy.mockClear();
             // These operations should all use the in-memory cache
             chatRecordingService.recordMessageTokens({
@@ -323,14 +359,13 @@ describe('ChatRecordingService', () => {
             chatRecordingService.saveSummary('Test summary');
             // readFileSync should NOT have been called since we use the in-memory cache
             expect(readFileSyncSpy).not.toHaveBeenCalled();
-            readFileSyncSpy.mockRestore();
         });
     });
     describe('recordToolCalls', () => {
-        beforeEach(() => {
-            chatRecordingService.initialize();
+        beforeEach(async () => {
+            await chatRecordingService.initialize();
         });
-        it('should add new tool calls to the last message', () => {
+        it('should add new tool calls to the last message', async () => {
             chatRecordingService.recordMessage({
                 type: 'gemini',
                 content: '',
@@ -345,12 +380,12 @@ describe('ChatRecordingService', () => {
             };
             chatRecordingService.recordToolCalls('gemini-pro', [toolCall]);
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             const geminiMsg = conversation.messages[0];
             expect(geminiMsg.toolCalls).toHaveLength(1);
             expect(geminiMsg.toolCalls[0].name).toBe('testTool');
         });
-        it('should preserve dynamic description and NOT overwrite with generic one', () => {
+        it('should preserve dynamic description and NOT overwrite with generic one', async () => {
             chatRecordingService.recordMessage({
                 type: 'gemini',
                 content: '',
@@ -367,11 +402,11 @@ describe('ChatRecordingService', () => {
             };
             chatRecordingService.recordToolCalls('gemini-pro', [toolCall]);
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             const geminiMsg = conversation.messages[0];
             expect(geminiMsg.toolCalls[0].description).toBe(dynamicDescription);
         });
-        it('should create a new message if the last message is not from gemini', () => {
+        it('should create a new message if the last message is not from gemini', async () => {
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'call a tool',
@@ -386,12 +421,33 @@ describe('ChatRecordingService', () => {
             };
             chatRecordingService.recordToolCalls('gemini-pro', [toolCall]);
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.messages).toHaveLength(2);
             expect(conversation.messages[1].type).toBe('gemini');
             expect(conversation.messages[1]
                 .toolCalls).toHaveLength(1);
         });
+        it('should record agentId when provided', async () => {
+            chatRecordingService.recordMessage({
+                type: 'gemini',
+                content: '',
+                model: 'gemini-pro',
+            });
+            const toolCall = {
+                id: 'tool-1',
+                name: 'testTool',
+                args: {},
+                status: CoreToolCallStatus.Success,
+                timestamp: new Date().toISOString(),
+                agentId: 'test-agent-id',
+            };
+            chatRecordingService.recordToolCalls('gemini-pro', [toolCall]);
+            const sessionFile = chatRecordingService.getConversationFilePath();
+            const conversation = (await loadConversationRecord(sessionFile));
+            const geminiMsg = conversation.messages[0];
+            expect(geminiMsg.toolCalls).toHaveLength(1);
+            expect(geminiMsg.toolCalls[0].agentId).toBe('test-agent-id');
+        });
     });
     describe('deleteSession', () => {
         it('should delete the session file, tool outputs, session directory, and logs if they exist', async () => {
@@ -406,8 +462,8 @@ describe('ChatRecordingService', () => {
             fs.mkdirSync(toolOutputsDir, { recursive: true });
             fs.mkdirSync(sessionDir, { recursive: true });
             // Create main session file with timestamp
-            const sessionFile = path.join(chatsDir, `session-2023-01-01T00-00-${shortId}.json`);
-            fs.writeFileSync(sessionFile, JSON.stringify({ sessionId }));
+            const sessionFile = path.join(chatsDir, `session-2023-01-01T00-00-${shortId}.jsonl`);
+            fs.writeFileSync(sessionFile, JSON.stringify({ sessionId }) + '\n');
             const logFile = path.join(logsDir, `session-${sessionId}.jsonl`);
             fs.writeFileSync(logFile, '{}');
             const toolOutputDir = path.join(toolOutputsDir, `session-${sessionId}`);
@@ -430,13 +486,14 @@ describe('ChatRecordingService', () => {
             fs.mkdirSync(logsDir, { recursive: true });
             fs.mkdirSync(toolOutputsDir, { recursive: true });
             // Create parent session file
-            const parentFile = path.join(chatsDir, `session-2023-01-01T00-00-${shortId}.json`);
-            fs.writeFileSync(parentFile, JSON.stringify({ sessionId: parentSessionId }));
+            const parentFile = path.join(chatsDir, `session-2023-01-01T00-00-${shortId}.jsonl`);
+            fs.writeFileSync(parentFile, JSON.stringify({ sessionId: parentSessionId }) + '\n');
             // Create subagent session file in subdirectory
             const subagentDir = path.join(chatsDir, parentSessionId);
             fs.mkdirSync(subagentDir, { recursive: true });
-            const subagentFile = path.join(subagentDir, `${subagentSessionId}.json`);
-            fs.writeFileSync(subagentFile, JSON.stringify({ sessionId: subagentSessionId, kind: 'subagent' }));
+            const subagentFile = path.join(subagentDir, `${subagentSessionId}.jsonl`);
+            fs.writeFileSync(subagentFile, JSON.stringify({ sessionId: subagentSessionId, kind: 'subagent' }) +
+                '\n');
             // Create logs for both
             const parentLog = path.join(logsDir, `session-${parentSessionId}.jsonl`);
             fs.writeFileSync(parentLog, '{}');
@@ -466,11 +523,12 @@ describe('ChatRecordingService', () => {
             fs.mkdirSync(chatsDir, { recursive: true });
             fs.mkdirSync(logsDir, { recursive: true });
             // Create parent session file
-            const parentFile = path.join(chatsDir, `session-2023-01-01T00-00-${shortId}.json`);
-            fs.writeFileSync(parentFile, JSON.stringify({ sessionId: parentSessionId }));
+            const parentFile = path.join(chatsDir, `session-2023-01-01T00-00-${shortId}.jsonl`);
+            fs.writeFileSync(parentFile, JSON.stringify({ sessionId: parentSessionId }) + '\n');
             // Create legacy subagent session file (flat in chatsDir)
-            const subagentFile = path.join(chatsDir, `session-2023-01-01T00-01-${shortId}.json`);
-            fs.writeFileSync(subagentFile, JSON.stringify({ sessionId: subagentSessionId, kind: 'subagent' }));
+            const subagentFile = path.join(chatsDir, `session-2023-01-01T00-01-${shortId}.jsonl`);
+            fs.writeFileSync(subagentFile, JSON.stringify({ sessionId: subagentSessionId, kind: 'subagent' }) +
+                '\n');
             // Call with parent sessionId
             await chatRecordingService.deleteSession(parentSessionId);
             expect(fs.existsSync(parentFile)).toBe(false);
@@ -484,8 +542,8 @@ describe('ChatRecordingService', () => {
             fs.mkdirSync(chatsDir, { recursive: true });
             fs.mkdirSync(logsDir, { recursive: true });
             const basename = `session-2023-01-01T00-00-${shortId}`;
-            const sessionFile = path.join(chatsDir, `${basename}.json`);
-            fs.writeFileSync(sessionFile, JSON.stringify({ sessionId }));
+            const sessionFile = path.join(chatsDir, `${basename}.jsonl`);
+            fs.writeFileSync(sessionFile, JSON.stringify({ sessionId }) + '\n');
             const logFile = path.join(logsDir, `session-${sessionId}.jsonl`);
             fs.writeFileSync(logFile, '{}');
             // Call with basename
@@ -498,10 +556,10 @@ describe('ChatRecordingService', () => {
         });
     });
     describe('recordDirectories', () => {
-        beforeEach(() => {
-            chatRecordingService.initialize();
+        beforeEach(async () => {
+            await chatRecordingService.initialize();
         });
-        it('should save directories to the conversation', () => {
+        it('should save directories to the conversation', async () => {
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'ping',
@@ -512,13 +570,13 @@ describe('ChatRecordingService', () => {
                 '/path/to/dir2',
             ]);
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.directories).toEqual([
                 '/path/to/dir1',
                 '/path/to/dir2',
             ]);
         });
-        it('should overwrite existing directories', () => {
+        it('should overwrite existing directories', async () => {
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'ping',
@@ -527,13 +585,13 @@ describe('ChatRecordingService', () => {
             chatRecordingService.recordDirectories(['/old/dir']);
             chatRecordingService.recordDirectories(['/new/dir1', '/new/dir2']);
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.directories).toEqual(['/new/dir1', '/new/dir2']);
         });
     });
     describe('rewindTo', () => {
-        it('should rewind the conversation to a specific message ID', () => {
-            chatRecordingService.initialize();
+        it('should rewind the conversation to a specific message ID', async () => {
+            await chatRecordingService.initialize();
             // Record some messages
             chatRecordingService.recordMessage({
                 type: 'user',
@@ -551,17 +609,17 @@ describe('ChatRecordingService', () => {
                 model: 'm',
             });
             const sessionFile = chatRecordingService.getConversationFilePath();
-            let conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            let conversation = (await loadConversationRecord(sessionFile));
             const secondMsgId = conversation.messages[1].id;
             const result = chatRecordingService.rewindTo(secondMsgId);
             expect(result).not.toBeNull();
             expect(result.messages).toHaveLength(1);
             expect(result.messages[0].content).toBe('msg1');
-            conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            conversation = (await loadConversationRecord(sessionFile));
             expect(conversation.messages).toHaveLength(1);
         });
-        it('should return the original conversation if the message ID is not found', () => {
-            chatRecordingService.initialize();
+        it('should return the original conversation if the message ID is not found', async () => {
+            await chatRecordingService.initialize();
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'msg1',
@@ -573,25 +631,23 @@ describe('ChatRecordingService', () => {
         });
     });
     describe('ENOSPC (disk full) graceful degradation - issue #16266', () => {
-        it('should disable recording and not throw when ENOSPC occurs during initialize', () => {
+        it('should disable recording and not throw when ENOSPC occurs during initialize', async () => {
             const enospcError = new Error('ENOSPC: no space left on device');
             enospcError.code = 'ENOSPC';
-            const mkdirSyncSpy = vi.spyOn(fs, 'mkdirSync').mockImplementation(() => {
+            const mkdirSyncSpy = vi.mocked(fs.mkdirSync).mockImplementation(() => {
                 throw enospcError;
             });
             // Should not throw
-            expect(() => chatRecordingService.initialize()).not.toThrow();
+            await expect(chatRecordingService.initialize()).resolves.not.toThrow();
             // Recording should be disabled (conversationFile set to null)
             expect(chatRecordingService.getConversationFilePath()).toBeNull();
             mkdirSyncSpy.mockRestore();
         });
-        it('should disable recording and not throw when ENOSPC occurs during writeConversation', () => {
-            chatRecordingService.initialize();
+        it('should disable recording and not throw when ENOSPC occurs during writeConversation', async () => {
+            await chatRecordingService.initialize();
             const enospcError = new Error('ENOSPC: no space left on device');
             enospcError.code = 'ENOSPC';
-            const writeFileSyncSpy = vi
-                .spyOn(fs, 'writeFileSync')
-                .mockImplementation(() => {
+            vi.mocked(fs.appendFileSync).mockImplementation(() => {
                 throw enospcError;
             });
             // Should not throw when recording a message
@@ -602,14 +658,13 @@ describe('ChatRecordingService', () => {
             })).not.toThrow();
             // Recording should be disabled (conversationFile set to null)
             expect(chatRecordingService.getConversationFilePath()).toBeNull();
-            writeFileSyncSpy.mockRestore();
         });
-        it('should skip recording operations when recording is disabled', () => {
-            chatRecordingService.initialize();
+        it('should skip recording operations when recording is disabled', async () => {
+            await chatRecordingService.initialize();
             const enospcError = new Error('ENOSPC: no space left on device');
             enospcError.code = 'ENOSPC';
-            const writeFileSyncSpy = vi
-                .spyOn(fs, 'writeFileSync')
+            const appendFileSyncSpy = vi
+                .mocked(fs.appendFileSync)
                 .mockImplementationOnce(() => {
                 throw enospcError;
             });
@@ -619,7 +674,7 @@ describe('ChatRecordingService', () => {
                 model: 'gemini-pro',
             });
             // Reset mock to track subsequent calls
-            writeFileSyncSpy.mockClear();
+            appendFileSyncSpy.mockClear();
             // Subsequent calls should be no-ops (not call writeFileSync)
             chatRecordingService.recordMessage({
                 type: 'user',
@@ -632,16 +687,13 @@ describe('ChatRecordingService', () => {
             });
             chatRecordingService.saveSummary('Test summary');
             // writeFileSync should not have been called for any of these
-            expect(writeFileSyncSpy).not.toHaveBeenCalled();
-            writeFileSyncSpy.mockRestore();
+            expect(appendFileSyncSpy).not.toHaveBeenCalled();
         });
-        it('should return null from getConversation when recording is disabled', () => {
-            chatRecordingService.initialize();
+        it('should return null from getConversation when recording is disabled', async () => {
+            await chatRecordingService.initialize();
             const enospcError = new Error('ENOSPC: no space left on device');
             enospcError.code = 'ENOSPC';
-            const writeFileSyncSpy = vi
-                .spyOn(fs, 'writeFileSync')
-                .mockImplementation(() => {
+            vi.mocked(fs.appendFileSync).mockImplementation(() => {
                 throw enospcError;
             });
             // Trigger ENOSPC
@@ -653,15 +705,12 @@ describe('ChatRecordingService', () => {
             // getConversation should return null when disabled
             expect(chatRecordingService.getConversation()).toBeNull();
             expect(chatRecordingService.getConversationFilePath()).toBeNull();
-            writeFileSyncSpy.mockRestore();
         });
-        it('should still throw for non-ENOSPC errors', () => {
-            chatRecordingService.initialize();
+        it('should still throw for non-ENOSPC errors', async () => {
+            await chatRecordingService.initialize();
             const otherError = new Error('Permission denied');
             otherError.code = 'EACCES';
-            const writeFileSyncSpy = vi
-                .spyOn(fs, 'writeFileSync')
-                .mockImplementation(() => {
+            vi.mocked(fs.appendFileSync).mockImplementation(() => {
                 throw otherError;
             });
             // Should throw for non-ENOSPC errors
@@ -672,14 +721,13 @@ describe('ChatRecordingService', () => {
             })).toThrow('Permission denied');
             // Recording should NOT be disabled for non-ENOSPC errors (file path still exists)
             expect(chatRecordingService.getConversationFilePath()).not.toBeNull();
-            writeFileSyncSpy.mockRestore();
         });
     });
     describe('updateMessagesFromHistory', () => {
-        beforeEach(() => {
-            chatRecordingService.initialize();
+        beforeEach(async () => {
+            await chatRecordingService.initialize();
         });
-        it('should update tool results from API history (masking sync)', () => {
+        it('should update tool results from API history (masking sync)', async () => {
             // 1. Record an initial message and tool call
             chatRecordingService.recordMessage({
                 type: 'gemini',
@@ -724,7 +772,7 @@ describe('ChatRecordingService', () => {
             chatRecordingService.updateMessagesFromHistory(history);
             // 4. Verify disk content
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             const geminiMsg = conversation.messages[0];
             if (geminiMsg.type !== 'gemini')
                 throw new Error('Expected gemini message');
@@ -741,8 +789,8 @@ describe('ChatRecordingService', () => {
                 output: maskedSnippet,
             });
         });
-        it('should preserve multi-modal sibling parts during sync', () => {
-            chatRecordingService.initialize();
+        it('should preserve multi-modal sibling parts during sync', async () => {
+            await chatRecordingService.initialize();
             const callId = 'multi-modal-call';
             const originalResult = [
                 {
@@ -787,7 +835,7 @@ describe('ChatRecordingService', () => {
             ];
             chatRecordingService.updateMessagesFromHistory(history);
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             const lastMsg = conversation.messages[0];
             const result = lastMsg.toolCalls[0].result;
             expect(result).toHaveLength(2);
@@ -797,8 +845,8 @@ describe('ChatRecordingService', () => {
             expect(result[1].inlineData).toBeDefined();
             expect(result[1].inlineData.mimeType).toBe('image/png');
         });
-        it('should handle parts appearing BEFORE the functionResponse in a content block', () => {
-            chatRecordingService.initialize();
+        it('should handle parts appearing BEFORE the functionResponse in a content block', async () => {
+            await chatRecordingService.initialize();
             const callId = 'prefix-part-call';
             chatRecordingService.recordMessage({
                 type: 'gemini',
@@ -832,21 +880,21 @@ describe('ChatRecordingService', () => {
             ];
             chatRecordingService.updateMessagesFromHistory(history);
             const sessionFile = chatRecordingService.getConversationFilePath();
-            const conversation = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+            const conversation = (await loadConversationRecord(sessionFile));
             const lastMsg = conversation.messages[0];
             const result = lastMsg.toolCalls[0].result;
             expect(result).toHaveLength(2);
             expect(result[0].text).toBe('Prefix metadata or text');
             expect(result[1].functionResponse.id).toBe(callId);
         });
-        it('should not write to disk when no tool calls match', () => {
+        it('should not write to disk when no tool calls match', async () => {
             chatRecordingService.recordMessage({
                 type: 'gemini',
                 content: 'Response with no tool calls',
                 model: 'gemini-pro',
             });
-            const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync');
-            writeFileSyncSpy.mockClear();
+            const appendFileSyncSpy = vi.mocked(fs.appendFileSync);
+            appendFileSyncSpy.mockClear();
             // History with a tool call ID that doesn't exist in the conversation
             const history = [
                 {
@@ -864,15 +912,14 @@ describe('ChatRecordingService', () => {
             ];
             chatRecordingService.updateMessagesFromHistory(history);
             // No tool calls matched, so writeFileSync should NOT have been called
-            expect(writeFileSyncSpy).not.toHaveBeenCalled();
-            writeFileSyncSpy.mockRestore();
+            expect(appendFileSyncSpy).not.toHaveBeenCalled();
         });
     });
     describe('ENOENT (missing directory) handling', () => {
-        it('should ensure directory exists before writing conversation file', () => {
-            chatRecordingService.initialize();
-            const mkdirSyncSpy = vi.spyOn(fs, 'mkdirSync');
-            const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync');
+        it('should ensure directory exists before writing conversation file', async () => {
+            await chatRecordingService.initialize();
+            const mkdirSyncSpy = vi.mocked(fs.mkdirSync);
+            const appendFileSyncSpy = vi.mocked(fs.appendFileSync);
             chatRecordingService.recordMessage({
                 type: 'user',
                 content: 'Hello after dir cleanup',
@@ -883,12 +930,11 @@ describe('ChatRecordingService', () => {
             expect(mkdirSyncSpy).toHaveBeenCalledWith(path.dirname(conversationFile), { recursive: true });
             // mkdirSync should be called before writeFileSync
             const mkdirCallOrder = mkdirSyncSpy.mock.invocationCallOrder;
-            const writeCallOrder = writeFileSyncSpy.mock.invocationCallOrder;
+            const writeCallOrder = appendFileSyncSpy.mock.invocationCallOrder;
             const lastMkdir = mkdirCallOrder[mkdirCallOrder.length - 1];
             const lastWrite = writeCallOrder[writeCallOrder.length - 1];
             expect(lastMkdir).toBeLessThan(lastWrite);
             mkdirSyncSpy.mockRestore();
-            writeFileSyncSpy.mockRestore();
         });
     });
 });