@qduc/term2 0.6.1 → 0.7.1

package/dist/services/conversation-persistence.test.js

@@ -3,18 +3,43 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import * as persistenceModule from './conversation-persistence.js';
+import { createConversationLogWriter, LockConflictError } from './conversation-log-writer.js';
+import { ConversationSession } from './conversation-session.js';
+import { createMockSettingsService } from './settings-service.mock.js';
 let testDir = '';
-// Clean up all conversation files before and after each test
 function cleanupAll() {
     if (testDir && fs.existsSync(testDir)) {
         fs.rmSync(testDir, { recursive: true, force: true });
     }
 }
-function waitForDistinctTimestamp() {
-    const start = Date.now();
-    while (Date.now() - start < 10) {
-        // busy wait for 10ms
-    }
+const stubLogger = {
+    error: () => { },
+    warn: () => { },
+    info: () => { },
+    debug: () => { },
+    trace: () => { },
+    getCorrelationId: () => undefined,
+};
+function emptySnapshot() {
+    return { history: [], previousResponseId: null, toolLedger: [] };
+}
+function assistantTurn(text, previousResponseId = 'r1') {
+    return {
+        type: 'assistant_turn',
+        turn: { items: [{ type: 'assistant_text', text }] },
+        state: { previousResponseId },
+    };
+}
+class MockStream {
+    completed = Promise.resolve(undefined);
+    lastResponseId = 'resp-v3';
+    interruptions = [];
+    state = {};
+    newItems = [];
+    history = [];
+    output = [];
+    finalOutput = 'Done.';
+    async *[Symbol.asyncIterator]() { }
 }
 test.beforeEach(() => {
     testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'term2-conversations-test-'));
@@ -30,684 +55,743 @@ test.serial('generateId: returns a valid UUID', (t) => {
     t.regex(id, /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
 });
 test.serial('generateId: returns unique IDs', (t) => {
-    const id1 = persistenceModule.generateId();
-    const id2 = persistenceModule.generateId();
-    t.not(id1, id2);
+    t.not(persistenceModule.generateId(), persistenceModule.generateId());
 });
 test.serial('getResumeCommand: returns correct format', (t) => {
     const id = 'test-uuid-123';
-    // Local (no SSH)
     t.is(persistenceModule.getResumeCommand(id), 'term2 --resume test-uuid-123');
-    // SSH with host
     t.is(persistenceModule.getResumeCommand(id, 'user@host'), 'term2 --ssh user@host --resume test-uuid-123');
-    // SSH with host and remote directory
-    t.is(persistenceModule.getResumeCommand(id, 'user@host', '/path/to/project'), 'term2 --ssh user@host --remote-dir /path/to/project --resume test-uuid-123');
-    // SSH with host, remote directory, and custom port
-    t.is(persistenceModule.getResumeCommand(id, 'user@host', '/path/to/project', 2222), 'term2 --ssh user@host --remote-dir /path/to/project --ssh-port 2222 --resume test-uuid-123');
-    // SSH with host and default port 22 (should be omitted)
-    t.is(persistenceModule.getResumeCommand(id, 'user@host', '/path/to/project', 22), 'term2 --ssh user@host --remote-dir /path/to/project --resume test-uuid-123');
-});
-test.serial('saveConversation: creates file and last.json pointer', (t) => {
+    t.is(persistenceModule.getResumeCommand(id, 'user@host', '/path'), 'term2 --ssh user@host --remote-dir /path --resume test-uuid-123');
+    t.is(persistenceModule.getResumeCommand(id, 'user@host', '/path', 2222), 'term2 --ssh user@host --remote-dir /path --ssh-port 2222 --resume test-uuid-123');
+});
+test.serial('writer + loadConversation: round-trips a basic conversation', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({
         id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
+        createdAt: '2026-05-26T00:00:00.000Z',
+        projectPath: '/workspace/x',
         model: 'gpt-4o',
-        previousResponseId: null,
-        history: [{ role: 'user', content: 'hello' }],
-        messages: [
-            { id: 'msg-1', sender: 'user', text: 'hello' },
-            { id: 'msg-2', sender: 'bot', text: 'hi there', status: 'finalized' },
-        ],
-    };
-    const filePath = persistenceModule.saveConversation(conversation);
-    t.true(fs.existsSync(filePath));
-    // Verify last.json was created
-    const lastPath = path.join(path.dirname(filePath), 'last.json');
-    t.true(fs.existsSync(lastPath));
-    const lastData = JSON.parse(fs.readFileSync(lastPath, 'utf-8'));
-    t.is(lastData.id, id);
-    // Cleanup
-    fs.rmSync(path.dirname(filePath), { recursive: true, force: true });
-});
-test.serial('getConversationsDirForTest: uses isolated test override', (t) => {
-    t.is(persistenceModule.getConversationsDirForTest(), testDir);
-});
-test.serial('saveConversation: normalizes streaming bot messages to finalized', (t) => {
+        provider: 'openai',
+    });
+    writer.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hello' } });
+    writer.append({
+        type: 'assistant_turn',
+        turn: { items: [{ type: 'assistant_text', text: 'hi there' }] },
+        state: { previousResponseId: 'resp-1', model: 'gpt-4o', provider: 'openai' },
+    });
+    void writer.close();
+    const restored = persistenceModule.loadConversation(id);
+    t.truthy(restored);
+    t.is(restored.id, id);
+    t.is(restored.previousResponseId, 'resp-1');
+    t.is(restored.history.length, 2);
+    t.is(restored.messages.length, 2);
+    t.is(restored.messages[0].sender, 'user');
+    t.is(restored.messages[1].sender, 'bot');
+});
+test.serial('loadConversation: returns null for missing id', (t) => {
+    t.is(persistenceModule.loadConversation('nope'), null);
+});
+test.serial('replay: mid-turn crash with tool_started inserts recovery notice', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        previousResponseId: null,
-        history: [],
-        messages: [
-            { id: 'msg-1', sender: 'user', text: 'hello' },
-            { id: 'msg-2', sender: 'bot', text: 'thinking...', status: 'streaming' },
-        ],
-    };
-    const filePath = persistenceModule.saveConversation(conversation);
-    const saved = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    t.is(saved.messages[1].status, 'finalized');
-    // Cleanup
-    fs.rmSync(path.dirname(filePath), { recursive: true, force: true });
-});
-test.serial('saveConversation: normalizes pending command messages to completed', (t) => {
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    // First turn completes cleanly
+    writer.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'do it' } });
+    writer.append(assistantTurn('done'));
+    // Second turn: user submits, tool starts, then crash
+    writer.append({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'more' } });
+    writer.append({ type: 'tool_started', toolCallId: 'call-1', toolName: 'shell', arguments: {} });
+    void writer.close();
+    const restored = persistenceModule.loadConversation(id);
+    t.truthy(restored);
+    t.true(restored.replayWarnings.some((w) => w.includes('interrupted')));
+    // The interrupted system message is on UI messages
+    t.true(restored.messages.some((m) => m.sender === 'system' && String(m.text).includes('interrupted')));
+});
+test.serial('replay: user_message only with no assistant_turn flags interruption', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'command', status: 'pending', command: 'ls', toolName: 'shell' }],
-    };
-    const filePath = persistenceModule.saveConversation(conversation);
-    const saved = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    t.is(saved.messages[0].status, 'completed');
-    t.is(saved.messages[0].success, false);
-    // Cleanup
-    fs.rmSync(path.dirname(filePath), { recursive: true, force: true });
-});
-test.serial('saveConversation: writes repaired history for duplicated tool replay artifacts', (t) => {
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    writer.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } });
+    void writer.close();
+    const restored = persistenceModule.loadConversation(id);
+    t.truthy(restored);
+    t.true(restored.replayWarnings.length > 0);
+    t.true(restored.messages.some((m) => m.sender === 'system' && String(m.text).includes('interrupted')));
+});
+test.serial('replay: settings_changed updates restored model', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        previousResponseId: 'resp-123',
-        history: [
-            { role: 'user', type: 'message', content: 'Inspect' },
-            { type: 'function_call', id: 'fc_1', callId: 'call-read', name: 'read_file', arguments: '{}' },
-            { type: 'function_call_result', id: 'fcr_1', callId: 'call-read', output: 'contents' },
-            { type: 'function_call', id: 'fc_2', callId: 'call-read', name: 'read_file', arguments: '{}' },
-            { type: 'function_call_result', id: 'fcr_2', callId: 'call-read', output: 'contents' },
-        ],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'Inspect' }],
-    };
-    const filePath = persistenceModule.saveConversation(conversation);
-    const saved = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    t.is(saved.previousResponseId, 'resp-123');
-    t.is(saved.history.length, 3);
-    t.deepEqual(saved.history.filter((item) => item.callId === 'call-read').map((item) => item.id), ['fc_1', 'fcr_1']);
-});
-test.serial('loadConversation: returns null for non-existent id', (t) => {
-    const result = persistenceModule.loadConversation('non-existent-id');
-    t.is(result, null);
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z', model: 'gpt-4o' });
+    writer.append({ type: 'settings_changed', key: 'agent.model', value: 'gpt-5' });
+    writer.append({
+        type: 'assistant_turn',
+        turn: { items: [{ type: 'assistant_text', text: 'ok' }] },
+        state: { previousResponseId: null, model: 'gpt-5' },
+    });
+    void writer.close();
+    const restored = persistenceModule.loadConversation(id);
+    t.is(restored.model, 'gpt-5');
 });
-test.serial('loadConversation: returns saved conversation', (t) => {
+test.serial('replay: undo with snapshot replaces state', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        model: 'gpt-4o',
-        previousResponseId: 'resp-123',
-        history: [{ role: 'user', content: 'hello' }],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const loaded = persistenceModule.loadConversation(id);
-    t.truthy(loaded);
-    t.is(loaded.id, id);
-    t.is(loaded.model, 'gpt-4o');
-    t.is(loaded.previousResponseId, 'resp-123');
-    t.is(loaded.messages.length, 1);
-    // Cleanup
-    const filePath = path.join(persistenceModule.getConversationsDirForTest(), `${id}.json`);
-    fs.rmSync(path.dirname(filePath), { recursive: true, force: true });
-});
-test.serial('loadConversation: returns repaired history with transient repair metadata', (t) => {
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    writer.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'first' } });
+    writer.append(assistantTurn('A'));
+    writer.append({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'second' } });
+    writer.append(assistantTurn('B', 'r2'));
+    writer.append({ type: 'undo', removedUserTurns: 1, snapshot: emptySnapshot() });
+    void writer.close();
+    const restored = persistenceModule.loadConversation(id);
+    t.is(restored.history.length, 0);
+    t.is(restored.previousResponseId, null);
+});
+test.serial('replay: corrupt line is skipped', (t) => {
     const id = persistenceModule.generateId();
-    const dir = persistenceModule.getConversationsDirForTest();
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify({
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        previousResponseId: 'resp-123',
-        history: [
-            { role: 'user', type: 'message', content: 'Inspect' },
-            { type: 'function_call', id: 'fc_1', callId: 'call-read', name: 'read_file', arguments: '{}' },
-            { type: 'function_call_result', id: 'fcr_1', callId: 'call-read', output: 'contents' },
-            { type: 'function_call', id: 'fc_2', callId: 'call-read', name: 'read_file', arguments: '{}' },
-            { type: 'function_call_result', id: 'fcr_2', callId: 'call-read', output: 'contents' },
-        ],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'Inspect' }],
-    }, null, 2), 'utf-8');
-    const loaded = persistenceModule.loadConversation(id);
-    t.truthy(loaded);
-    t.is(loaded.previousResponseId, 'resp-123');
-    t.is(loaded.history.length, 3);
-    t.true(loaded.historyRepair?.repaired);
-    t.is(loaded.historyRepair?.removedItems, 2);
-});
-test.serial('loadConversation: preserves saved app mode settings', (t) => {
-    const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        appMode: {
-            liteMode: false,
-            mentorMode: true,
-            planMode: true,
-            orchestratorMode: false,
+    fs.mkdirSync(testDir, { recursive: true });
+    const filePath = path.join(testDir, `${id}.jsonl`);
+    const goodInit = JSON.stringify({
+        v: 1,
+        seq: 1,
+        ts: '2026-05-26T00:00:00.000Z',
+        event: { type: 'session_init', id, createdAt: '2026-05-26T00:00:00.000Z' },
+    });
+    const goodTurn = JSON.stringify({
+        v: 3,
+        seq: 3,
+        ts: '2026-05-26T00:00:01.000Z',
+        event: {
+            type: 'assistant_turn',
+            turn: { items: [{ type: 'assistant_text', text: 'ok' }] },
+            state: { previousResponseId: 'r1' },
         },
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const loaded = persistenceModule.loadConversation(id);
-    t.deepEqual(loaded?.appMode, {
-        liteMode: false,
-        mentorMode: true,
-        planMode: true,
-        orchestratorMode: false,
     });
+    fs.writeFileSync(filePath, `${goodInit}\n{not json\n${goodTurn}\n`, 'utf-8');
+    const restored = persistenceModule.loadConversation(id);
+    t.is(restored.previousResponseId, 'r1');
 });
-test.serial('loadConversation: returns null when saved project path differs from expected path', (t) => {
+test.serial('lock: collision throws LockConflictError', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const loaded = persistenceModule.loadConversation(id, '/workspace/beta');
-    t.is(loaded, null);
+    const w1 = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    w1.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    const w2 = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    t.throws(() => w2.init({ id, createdAt: '2026-05-26T00:00:00.000Z' }), { instanceOf: LockConflictError });
+    void w1.close();
 });
-test.serial('loadConversationForProject: reports project mismatch for existing conversation in another path', (t) => {
+test.serial('lock: released on writer close, second writer succeeds', async (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const result = persistenceModule.loadConversationForProject(id, '/workspace/beta');
-    t.is(result.status, 'project_mismatch');
-    if (result.status !== 'project_mismatch') {
-        t.fail('expected project_mismatch');
-        return;
+    const w1 = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    w1.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    await w1.close();
+    const w2 = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    t.notThrows(() => w2.init({ id, createdAt: '2026-05-26T00:00:00.000Z' }));
+    await w2.close();
+});
+test.serial('forkConversation: copies the source jsonl to a new id', (t) => {
+    const srcId = persistenceModule.generateId();
+    const dstId = persistenceModule.generateId();
+    const writer = createConversationLogWriter({ sessionId: srcId, dir: testDir, logger: stubLogger });
+    writer.init({ id: srcId, createdAt: '2026-05-26T00:00:00.000Z' });
+    writer.append(assistantTurn('A'));
+    void writer.close();
+    t.true(persistenceModule.forkConversation(srcId, dstId));
+    const restored = persistenceModule.loadConversation(dstId);
+    t.is(restored.previousResponseId, 'r1');
+});
+test.serial('listConversations: lists sessions sorted by mtime desc', (t) => {
+    const id1 = persistenceModule.generateId();
+    const w1 = createConversationLogWriter({ sessionId: id1, dir: testDir, logger: stubLogger });
+    w1.init({ id: id1, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/p1' });
+    void w1.close();
+    // Sleep to ensure mtime differs
+    const target = Date.now() + 20;
+    while (Date.now() < target) {
+        /* spin */
     }
-    t.is(result.conversation.id, id);
-});
-test.serial('loadConversationForProject: reports not_found for missing conversation', (t) => {
-    const result = persistenceModule.loadConversationForProject('missing-id', '/workspace/beta');
-    t.is(result.status, 'not_found');
+    const id2 = persistenceModule.generateId();
+    const w2 = createConversationLogWriter({ sessionId: id2, dir: testDir, logger: stubLogger });
+    w2.init({ id: id2, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/p2' });
+    void w2.close();
+    const list = persistenceModule.listConversations();
+    t.is(list.length, 2);
+    t.is(list[0].id, id2);
+    t.is(list[0].projectPath, '/p2');
 });
-test.serial('loadConversation: returns saved conversation when expected project path matches', (t) => {
+test.serial('loadConversation: returns null when expected project path differs', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const loaded = persistenceModule.loadConversation(id, '/workspace/alpha');
-    t.truthy(loaded);
-    t.is(loaded.id, id);
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/workspace/alpha' });
+    void writer.close();
+    t.is(persistenceModule.loadConversation(id, '/workspace/beta'), null);
 });
-test.serial('loadConversation: unscoped loads keep backward-compatible behavior', (t) => {
+test.serial('loadConversationForProject: reports project mismatch', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const loaded = persistenceModule.loadConversation(id);
-    t.truthy(loaded);
-    t.is(loaded.id, id);
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/workspace/alpha' });
+    void writer.close();
+    const result = persistenceModule.loadConversationForProject(id, '/workspace/beta');
+    t.is(result.status, 'project_mismatch');
 });
-test.serial('loadLastConversation: returns null when no last.json exists', (t) => {
-    const result = persistenceModule.loadLastConversation();
-    t.is(result, null);
+test.serial('loadConversationForProject: not_found for missing', (t) => {
+    t.is(persistenceModule.loadConversationForProject('missing', '/x').status, 'not_found');
 });
-test.serial('loadLastConversation: returns the last saved conversation', (t) => {
+test.serial('loadLastConversation: returns the last written conversation', (t) => {
     const id1 = persistenceModule.generateId();
+    const w1 = createConversationLogWriter({ sessionId: id1, dir: testDir, logger: stubLogger });
+    w1.init({ id: id1, createdAt: '2026-05-26T00:00:00.000Z' });
+    w1.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } });
+    void w1.close();
+    const target = Date.now() + 20;
+    while (Date.now() < target) {
+        /* spin */
+    }
     const id2 = persistenceModule.generateId();
-    const conv1 = {
-        id: id1,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'first' }],
-    };
-    const conv2 = {
-        id: id2,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-2', sender: 'user', text: 'second' }],
-    };
-    persistenceModule.saveConversation(conv1);
-    persistenceModule.saveConversation(conv2);
+    const w2 = createConversationLogWriter({ sessionId: id2, dir: testDir, logger: stubLogger });
+    w2.init({ id: id2, createdAt: '2026-05-26T00:00:00.000Z' });
+    w2.append({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'hi2' } });
+    void w2.close();
     const last = persistenceModule.loadLastConversation();
     t.truthy(last);
     t.is(last.id, id2);
-    // Cleanup
-    fs.rmSync(persistenceModule.getConversationsDirForTest(), { recursive: true, force: true });
 });
-test.serial('loadLastConversation: surfaces repaired conversation metadata', (t) => {
+test.serial('loadLastConversation: does not save last.json for empty conversation', (t) => {
     const id = persistenceModule.generateId();
-    const dir = persistenceModule.getConversationsDirForTest();
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify({
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        previousResponseId: null,
-        history: [
-            { role: 'user', type: 'message', content: 'Inspect' },
-            { type: 'function_call', id: 'fc_1', callId: 'call-read', name: 'read_file', arguments: '{}' },
-            { type: 'function_call_result', id: 'fcr_1', callId: 'call-read', output: 'contents' },
-            { type: 'function_call', id: 'fc_2', callId: 'call-read', name: 'read_file', arguments: '{}' },
-            { type: 'function_call_result', id: 'fcr_2', callId: 'call-read', output: 'contents' },
-        ],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'Inspect' }],
-    }, null, 2), 'utf-8');
-    fs.writeFileSync(path.join(dir, 'last.json'), JSON.stringify({ id }), 'utf-8');
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    void writer.close();
     const last = persistenceModule.loadLastConversation();
-    t.truthy(last);
-    t.true(last.historyRepair?.repaired);
-    t.is(last.history.length, 3);
-});
-test.serial('loadLastConversation: returns most recent conversation for expected project path', (t) => {
-    const projectAOlder = persistenceModule.generateId();
-    const projectANewer = persistenceModule.generateId();
-    const projectBNewer = persistenceModule.generateId();
-    persistenceModule.saveConversation({
-        id: projectAOlder,
-        createdAt: '2024-01-01T00:00:00.000Z',
-        updatedAt: '2024-01-01T00:00:00.000Z',
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'alpha older' }],
-    });
-    waitForDistinctTimestamp();
-    persistenceModule.saveConversation({
-        id: projectANewer,
-        createdAt: '2024-01-02T00:00:00.000Z',
-        updatedAt: '2024-01-02T00:00:00.000Z',
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-2', sender: 'user', text: 'alpha newer' }],
-    });
-    waitForDistinctTimestamp();
-    persistenceModule.saveConversation({
-        id: projectBNewer,
-        createdAt: '2024-01-03T00:00:00.000Z',
-        updatedAt: '2024-01-03T00:00:00.000Z',
-        projectPath: '/workspace/beta',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-3', sender: 'user', text: 'beta newer' }],
-    });
-    const last = persistenceModule.loadLastConversation('/workspace/alpha');
-    t.truthy(last);
-    t.is(last.id, projectANewer);
-});
-test.serial('loadLastConversation: returns null when no conversation matches expected project path', (t) => {
-    persistenceModule.saveConversation({
-        id: persistenceModule.generateId(),
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'alpha' }],
-    });
-    const last = persistenceModule.loadLastConversation('/workspace/beta');
     t.is(last, null);
+    t.false(fs.existsSync(path.join(testDir, 'last.json')));
 });
-test.serial('deleteConversation: removes the conversation file', (t) => {
-    const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        previousResponseId: null,
-        history: [],
-        messages: [],
-    };
-    persistenceModule.saveConversation(conversation);
-    const result = persistenceModule.deleteConversation(id);
-    t.true(result);
-    t.is(persistenceModule.loadConversation(id), null);
-    // Cleanup
-    fs.rmSync(persistenceModule.getConversationsDirForTest(), { recursive: true, force: true });
-});
-test.serial('deleteConversation: returns false for non-existent id', (t) => {
-    const result = persistenceModule.deleteConversation('non-existent');
-    t.false(result);
-});
-test.serial('listConversations: returns empty array when no conversations exist', (t) => {
-    // Ensure dir exists but is empty
-    const dir = persistenceModule.getConversationsDirForTest();
-    if (fs.existsSync(dir)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-    const list = persistenceModule.listConversations();
-    t.deepEqual(list, []);
+test.serial('hasConversationContent: returns false for missing conversation', (t) => {
+    t.false(persistenceModule.hasConversationContent('non-existent-id'));
 });
-test.serial('loadConversation: old save without orchestratorMode — resolves to false, no error', (t) => {
+test.serial('hasConversationContent: returns false for empty conversation', (t) => {
     const id = persistenceModule.generateId();
-    // Write a raw JSON file that looks like an old save (missing orchestratorMode)
-    const dir = persistenceModule.getConversationsDirForTest();
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    const rawData = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        appMode: {
-            mentorMode: false,
-            liteMode: false,
-            planMode: false,
-            // orchestratorMode is intentionally absent (old format)
-        },
-        previousResponseId: null,
-        history: [],
-        messages: [],
-    };
-    fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify(rawData, null, 2), 'utf-8');
-    // loadConversation should not throw — it returns null on error
-    const loaded = persistenceModule.loadConversation(id);
-    t.truthy(loaded);
-    // orchestratorMode should be absent or false-y, not throw
-    const orchestratorMode = loaded?.appMode?.orchestratorMode;
-    t.falsy(orchestratorMode, 'orchestratorMode missing from old save should not be truthy');
-});
-test.serial('loadConversation: save with orchestratorMode: true is correctly restored', (t) => {
-    const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        appMode: {
-            mentorMode: false,
-            liteMode: false,
-            planMode: false,
-            orchestratorMode: true,
-        },
-        previousResponseId: null,
-        history: [],
-        messages: [],
-    };
-    persistenceModule.saveConversation(conversation);
-    const loaded = persistenceModule.loadConversation(id);
-    t.truthy(loaded);
-    t.is(loaded?.appMode?.orchestratorMode, true);
-});
-test.serial('listConversations: returns conversations sorted by updatedAt descending', (t) => {
-    const id1 = persistenceModule.generateId();
-    const id2 = persistenceModule.generateId();
-    const conv1 = {
-        id: id1,
-        createdAt: '2024-01-01T00:00:00.000Z',
-        updatedAt: '2024-01-01T00:00:00.000Z',
-        previousResponseId: null,
-        history: [],
-        messages: [],
-    };
-    const conv2 = {
-        id: id2,
-        createdAt: '2024-01-02T00:00:00.000Z',
-        updatedAt: '2024-01-02T00:00:00.000Z',
-        previousResponseId: null,
-        history: [],
-        messages: [],
-    };
-    // Save conv1 first
-    persistenceModule.saveConversation(conv1);
-    // Wait a moment so updatedAt differs
-    waitForDistinctTimestamp();
-    // Save conv2 second (should have later updatedAt)
-    persistenceModule.saveConversation(conv2);
-    const list = persistenceModule.listConversations();
-    t.is(list.length, 2);
-    t.is(list[0].id, id2); // Most recently saved first
-    t.is(list[1].id, id1);
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    void writer.close();
+    t.false(persistenceModule.hasConversationContent(id));
 });
-test.serial('conversationMatchesProject: loadConversation with matching sshHost returns conversation', (t) => {
+test.serial('hasConversationContent: returns true for user_message', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sshHost: 'myhost.example.com',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const loaded = persistenceModule.loadConversation(id, undefined, 'myhost.example.com');
-    t.truthy(loaded);
-    t.is(loaded.id, id);
-    t.is(loaded.sshHost, 'myhost.example.com');
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    writer.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } });
+    void writer.close();
+    t.true(persistenceModule.hasConversationContent(id));
 });
-test.serial('conversationMatchesProject: loadConversation with mismatched sshHost returns null', (t) => {
+test.serial('hasConversationContent: returns true for assistant_turn', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sshHost: 'myhost.example.com',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const loaded = persistenceModule.loadConversation(id, undefined, 'otherhost.example.com');
-    t.is(loaded, null);
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    writer.append(assistantTurn('hello'));
+    void writer.close();
+    t.true(persistenceModule.hasConversationContent(id));
 });
-test.serial('conversationMatchesProject: loading remote conversation from local session (no expectedSshHost) returns null', (t) => {
+test.serial('hasConversationContent: ignores unsupported assistant_final events', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sshHost: 'remote.example.com',
-        projectPath: '/workspace/project',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    // Local session (expectedProjectPath given, but no expectedSshHost)
-    // should reject a remote conversation that has sshHost
-    const loaded = persistenceModule.loadConversation(id, '/workspace/project', undefined);
-    t.is(loaded, null);
-});
-test.serial('conversationMatchesProject: loading local conversation from remote session (no conversation.sshHost) returns null', (t) => {
+    const filePath = path.join(testDir, `${id}.jsonl`);
+    fs.writeFileSync(filePath, JSON.stringify({
+        v: 1,
+        seq: 1,
+        ts: '2026-05-26T00:00:00.000Z',
+        event: { type: 'assistant_final', message: { id: 'a1', sender: 'bot', text: 'legacy' } },
+    }) + '\n', 'utf-8');
+    t.false(persistenceModule.hasConversationContent(id));
+});
+test.serial('hasConversationContent: skips corrupt lines and finds content', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        // no sshHost — local conversation
-        projectPath: '/workspace/project',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    // Remote session (expectedSshHost given) should reject a local conversation
-    const loaded = persistenceModule.loadConversation(id, '/workspace/project', 'remote.example.com');
-    t.is(loaded, null);
-});
-test.serial('loadConversationForProject: returns project_mismatch for sshHost mismatch', (t) => {
+    const filePath = path.join(testDir, `${id}.jsonl`);
+    fs.writeFileSync(filePath, '{"v":1,"seq":1,"ts":"2026-05-26T00:00:00.000Z","event":{"type":"session_init","id":"' +
+        id +
+        '","createdAt":"2026-05-26T00:00:00.000Z"}}\n' +
+        'this is not json\n' +
+        '{"v":1,"seq":2,"ts":"2026-05-26T00:00:01.000Z","event":{"type":"user_message","message":{"id":"u1","sender":"user","text":"hi"}}}\n', 'utf-8');
+    t.true(persistenceModule.hasConversationContent(id));
+});
+test.serial('deleteConversation: removes the jsonl and clears last.json', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sshHost: 'myhost.example.com',
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const result = persistenceModule.loadConversationForProject(id, '/workspace/alpha', 'otherhost.example.com');
-    t.is(result.status, 'project_mismatch');
-    if (result.status === 'project_mismatch') {
-        t.is(result.conversation.id, id);
-        t.is(result.conversation.sshHost, 'myhost.example.com');
-    }
-});
-test.serial('loadConversationForProject: returns project_mismatch for project path mismatch with sshHost', (t) => {
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    writer.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } });
+    void writer.close();
+    t.true(persistenceModule.deleteConversation(id));
+    t.false(fs.existsSync(path.join(testDir, `${id}.jsonl`)));
+    t.false(fs.existsSync(path.join(testDir, 'last.json')));
+});
+test.serial('subagent_completed and corresponding records omit nestedRunResult', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sshHost: 'myhost.example.com',
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const result = persistenceModule.loadConversationForProject(id, '/workspace/beta', 'myhost.example.com');
-    t.is(result.status, 'project_mismatch');
-    if (result.status === 'project_mismatch') {
-        t.is(result.conversation.id, id);
-    }
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    // 1. Log subagent_completed event
+    writer.append({
+        type: 'subagent_completed',
+        result: {
+            agentId: 'sub-agent-1',
+            role: 'worker',
+            status: 'completed',
+            finalText: 'Task resolved successfully',
+            filesChanged: ['src/app.ts'],
+            toolsUsed: [{ toolName: 'create_file', count: 1 }],
+            usage: { prompt_tokens: 120, completion_tokens: 80, total_tokens: 200 },
+            nestedRunResult: {
+                state: {
+                    history: [{ role: 'user', content: 'test' }],
+                    generatedItems: ['item1'],
+                },
+            },
+        },
+    });
+    // 2. Log tool_result event with JSON string containing nestedRunResult
+    writer.append({
+        type: 'tool_result',
+        callId: 'call-subagent-1',
+        toolName: 'run_subagent',
+        status: 'completed',
+        output: JSON.stringify({
+            status: 'completed',
+            finalText: 'Result text',
+            nestedRunResult: { state: { internalStuff: 'hidden' } },
+        }),
+    });
+    // 3. Log assistant_turn event with nestedRunResult in turn items
+    writer.append({
+        type: 'assistant_turn',
+        turn: {
+            items: [
+                {
+                    type: 'tool_result',
+                    callId: 'call-subagent-1',
+                    toolName: 'run_subagent',
+                    status: 'completed',
+                    output: JSON.stringify({
+                        status: 'completed',
+                        finalText: 'Turn result text',
+                        nestedRunResult: { state: { internalStuff: 'hidden' } },
+                    }),
+                },
+                { type: 'assistant_text', text: 'all done' },
+            ],
+        },
+        state: { previousResponseId: 'resp-1' },
+    });
+    void writer.close();
+    // Load raw file contents to check what was written to disk
+    const filePath = path.join(testDir, `${id}.jsonl`);
+    const lines = fs.readFileSync(filePath, 'utf-8').trim().split('\n');
+    // Parse lines to check events
+    const envelopes = lines.map((line) => JSON.parse(line));
+    // Find subagent_completed
+    const completedEnv = envelopes.find((env) => env.event?.type === 'subagent_completed');
+    t.truthy(completedEnv);
+    t.is(completedEnv.event.result.status, 'completed');
+    t.is(completedEnv.event.result.finalText, 'Task resolved successfully');
+    t.deepEqual(completedEnv.event.result.filesChanged, ['src/app.ts']);
+    t.is(completedEnv.event.result.nestedRunResult, undefined);
+    // Find tool_result
+    const toolResultEnv = envelopes.find((env) => env.event?.type === 'tool_result');
+    t.truthy(toolResultEnv);
+    t.is(toolResultEnv.event.toolName, 'run_subagent');
+    const parsedOutput = JSON.parse(toolResultEnv.event.output);
+    t.is(parsedOutput.status, 'completed');
+    t.is(parsedOutput.finalText, 'Result text');
+    t.is(parsedOutput.nestedRunResult, undefined);
+    // Find assistant_turn and check turn items
+    const turnEnv = envelopes.find((env) => env.event?.type === 'assistant_turn');
+    t.truthy(turnEnv);
+    const turnOutput = JSON.parse(turnEnv.event.turn.items[0].output);
+    t.is(turnOutput.status, 'completed');
+    t.is(turnOutput.finalText, 'Turn result text');
+    t.is(turnOutput.nestedRunResult, undefined);
+});
+test.serial('saveLastConversation: stores per-project last conversation', (t) => {
+    const id1 = persistenceModule.generateId();
+    const w1 = createConversationLogWriter({ sessionId: id1, dir: testDir, logger: stubLogger });
+    w1.init({ id: id1, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/project-a' });
+    w1.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi a' } });
+    void w1.close();
+    const id2 = persistenceModule.generateId();
+    const w2 = createConversationLogWriter({ sessionId: id2, dir: testDir, logger: stubLogger });
+    w2.init({ id: id2, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/project-b' });
+    w2.append({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'hi b' } });
+    void w2.close();
+    const lastA = persistenceModule.loadLastConversation('/project-a');
+    t.truthy(lastA);
+    t.is(lastA.id, id1);
+    const lastB = persistenceModule.loadLastConversation('/project-b');
+    t.truthy(lastB);
+    t.is(lastB.id, id2);
+});
+test.serial('saveLastConversation: stores per-ssh-host last conversation', (t) => {
+    const id1 = persistenceModule.generateId();
+    const w1 = createConversationLogWriter({ sessionId: id1, dir: testDir, logger: stubLogger });
+    w1.init({ id: id1, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/remote', sshHost: 'host-a' });
+    w1.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi a' } });
+    void w1.close();
+    const id2 = persistenceModule.generateId();
+    const w2 = createConversationLogWriter({ sessionId: id2, dir: testDir, logger: stubLogger });
+    w2.init({ id: id2, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/remote', sshHost: 'host-b' });
+    w2.append({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'hi b' } });
+    void w2.close();
+    const lastA = persistenceModule.loadLastConversation('/remote', 'host-a');
+    t.truthy(lastA);
+    t.is(lastA.id, id1);
+    const lastB = persistenceModule.loadLastConversation('/remote', 'host-b');
+    t.truthy(lastB);
+    t.is(lastB.id, id2);
+});
+test.serial('loadLastConversation: falls back to scanning when no last.json entry matches', (t) => {
+    const id = persistenceModule.generateId();
+    const w = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    w.init({ id, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/fallback' });
+    w.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } });
+    void w.close();
+    // Directly overwrite last.json so the entry has no projectPath
+    fs.writeFileSync(path.join(testDir, 'last.json'), JSON.stringify({ entries: [{ id, updatedAt: new Date().toISOString() }] }), 'utf-8');
+    const last = persistenceModule.loadLastConversation('/fallback');
+    t.truthy(last);
+    t.is(last.id, id);
 });
-test.serial('loadConversationForProject: returns loaded when both sshHost and projectPath match', (t) => {
+test.serial('loadLastConversation: migrates old last.json format', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
-        id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sshHost: 'myhost.example.com',
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const result = persistenceModule.loadConversationForProject(id, '/workspace/alpha', 'myhost.example.com');
-    t.is(result.status, 'loaded');
-    if (result.status === 'loaded') {
-        t.is(result.conversation.id, id);
-        t.is(result.conversation.sshHost, 'myhost.example.com');
-    }
+    const w = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    w.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    w.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } });
+    void w.close();
+    // Simulate old format
+    fs.writeFileSync(path.join(testDir, 'last.json'), JSON.stringify({ id, updatedAt: '2026-05-26T00:00:00.000Z' }), 'utf-8');
+    const last = persistenceModule.loadLastConversation();
+    t.truthy(last);
+    t.is(last.id, id);
 });
-test.serial('loadConversationForProject: SSH host matching is case-insensitive', (t) => {
+test.serial('deleteConversation: removes only matching entry from last.json', (t) => {
+    const id1 = persistenceModule.generateId();
+    const w1 = createConversationLogWriter({ sessionId: id1, dir: testDir, logger: stubLogger });
+    w1.init({ id: id1, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/project-a' });
+    w1.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi a' } });
+    void w1.close();
+    const id2 = persistenceModule.generateId();
+    const w2 = createConversationLogWriter({ sessionId: id2, dir: testDir, logger: stubLogger });
+    w2.init({ id: id2, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/project-b' });
+    w2.append({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'hi b' } });
+    void w2.close();
+    t.true(persistenceModule.deleteConversation(id1));
+    t.false(fs.existsSync(path.join(testDir, `${id1}.jsonl`)));
+    t.true(fs.existsSync(path.join(testDir, 'last.json')));
+    const lastB = persistenceModule.loadLastConversation('/project-b');
+    t.truthy(lastB);
+    t.is(lastB.id, id2);
+});
+test.serial('saveLastConversation: updates entry when projectPath changes for same id', (t) => {
+    const id = persistenceModule.generateId();
+    const w = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    w.init({ id, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/old-path' });
+    w.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'hi' } });
+    void w.close();
+    // Re-open same session with different project path (simulating rotate or manual update)
+    const w2 = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    w2.init({ id, createdAt: '2026-05-26T00:00:00.000Z', projectPath: '/new-path' });
+    w2.append({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'hi again' } });
+    void w2.close();
+    t.is(persistenceModule.loadLastConversation('/old-path'), null);
+    const lastNew = persistenceModule.loadLastConversation('/new-path');
+    t.truthy(lastNew);
+    t.is(lastNew.id, id);
+});
+// Suppress unused-event-import lint
+const _ev = null;
+void _ev;
+test.serial('writer + loadConversation: round-trips a v2 conversation with assistant_turn', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({
         id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sshHost: 'MyHost.EXAMPLE.COM',
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
-    };
-    persistenceModule.saveConversation(conversation);
-    const result = persistenceModule.loadConversationForProject(id, '/workspace/alpha', 'myhost.example.com');
-    t.is(result.status, 'loaded');
-    if (result.status === 'loaded') {
-        t.is(result.conversation.id, id);
-    }
-});
-test.serial('loadLastConversation: filters by both expectedProjectPath and expectedSshHost', (t) => {
-    const matchingId = persistenceModule.generateId();
-    const wrongSshId = persistenceModule.generateId();
-    const wrongProjectId = persistenceModule.generateId();
-    persistenceModule.saveConversation({
-        id: matchingId,
-        createdAt: '2024-01-03T00:00:00.000Z',
-        updatedAt: '2024-01-03T00:00:00.000Z',
-        projectPath: '/workspace/alpha',
-        sshHost: 'myhost.example.com',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'matching' }],
+        createdAt: '2026-05-26T00:00:00.000Z',
+        projectPath: '/workspace/y',
+        model: 'gpt-4o',
+        provider: 'openai',
     });
-    persistenceModule.saveConversation({
-        id: wrongSshId,
-        createdAt: '2024-01-02T00:00:00.000Z',
-        updatedAt: '2024-01-02T00:00:00.000Z',
-        projectPath: '/workspace/alpha',
-        sshHost: 'other.example.com',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-2', sender: 'user', text: 'wrong ssh' }],
+    writer.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'run tool' } });
+    writer.append({ type: 'tool_started', toolCallId: 'call-v2', toolName: 'shell', arguments: 'ls' });
+    writer.append({
+        type: 'command_message',
+        message: {
+            id: 'cmd-v2',
+            sender: 'command',
+            status: 'completed',
+            command: 'ls',
+            output: 'file.txt',
+            success: true,
+            callId: 'call-v2',
+            toolName: 'shell',
+        },
     });
-    persistenceModule.saveConversation({
-        id: wrongProjectId,
-        createdAt: '2024-01-01T00:00:00.000Z',
-        updatedAt: '2024-01-01T00:00:00.000Z',
-        projectPath: '/workspace/beta',
-        sshHost: 'myhost.example.com',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-3', sender: 'user', text: 'wrong project' }],
+    writer.append({
+        type: 'assistant_turn',
+        turn: {
+            items: [
+                { type: 'reasoning', text: 'thinking about ls' },
+                { type: 'tool_call', callId: 'call-v2', toolName: 'shell', arguments: 'ls' },
+                { type: 'tool_result', callId: 'call-v2', toolName: 'shell', status: 'completed', output: 'file.txt' },
+                { type: 'assistant_text', text: 'here is the file' },
+            ],
+        },
+        snapshot: {
+            history: [
+                { role: 'user', type: 'message', content: 'run tool' },
+                { role: 'assistant', type: 'message', content: 'here is the file' },
+            ],
+            previousResponseId: 'resp-v2',
+            toolLedger: [
+                {
+                    turnId: 'turn-1',
+                    callId: 'call-v2',
+                    toolName: 'shell',
+                    status: 'completed',
+                    startedAt: '2026-05-26T00:00:00.000Z',
+                    completedAt: '2026-05-26T00:00:01.000Z',
+                    arguments: 'ls',
+                    output: 'file.txt',
+                },
+            ],
+            model: 'gpt-4o',
+            provider: 'openai',
+        },
     });
-    const last = persistenceModule.loadLastConversation('/workspace/alpha', 'myhost.example.com');
-    t.truthy(last);
-    t.is(last.id, matchingId);
-});
-test.serial('loadLastConversation: returns null when no conversation matches both project and ssh', (t) => {
-    persistenceModule.saveConversation({
-        id: persistenceModule.generateId(),
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        projectPath: '/workspace/alpha',
-        sshHost: 'myhost.example.com',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
+    void writer.close();
+    const restored = persistenceModule.loadConversation(id);
+    t.truthy(restored);
+    t.is(restored.id, id);
+    t.is(restored.previousResponseId, 'resp-v2');
+    // Reasoning is reconstructed as a standalone history item (matching the live SDK
+    // output), NOT folded into the following tool_call's providerData. Folding caused
+    // the reasoning_content to be serialized onto both the assistant message and the
+    // tool call (duplicate reasoning_content) by the chat-completions converter.
+    t.is(restored.history.length, 5);
+    t.deepEqual(restored.history[0], { role: 'user', type: 'message', content: 'run tool' });
+    t.deepEqual(restored.history[1], {
+        type: 'reasoning',
+        content: [{ type: 'reasoning_text', text: 'thinking about ls' }],
+        rawContent: [{ type: 'reasoning_text', text: 'thinking about ls' }],
     });
-    const last = persistenceModule.loadLastConversation('/workspace/alpha', 'otherhost.example.com');
-    t.is(last, null);
+    t.deepEqual(restored.history[2], {
+        type: 'function_call',
+        callId: 'call-v2',
+        name: 'shell',
+        arguments: 'ls',
+    });
+    t.deepEqual(restored.history[3], {
+        type: 'function_call_result',
+        callId: 'call-v2',
+        name: 'shell',
+        output: 'file.txt',
+    });
+    t.deepEqual(restored.history[4], {
+        role: 'assistant',
+        type: 'message',
+        status: 'completed',
+        content: [{ type: 'output_text', text: 'here is the file' }],
+    });
+    t.is(restored.toolLedger.length, 1);
+    t.is(restored.toolLedger[0].callId, 'call-v2');
+    // exact messages ordering: user, reasoning, command, bot
+    t.is(restored.messages.length, 4);
+    t.is(restored.messages[0].sender, 'user');
+    t.is(restored.messages[1].sender, 'reasoning');
+    t.is(restored.messages[1].text, 'thinking about ls');
+    t.is(restored.messages[2].sender, 'command');
+    t.is(restored.messages[2].status, 'completed');
+    t.is(restored.messages[3].sender, 'bot');
+    t.is(restored.messages[3].text, 'here is the file');
+});
+test.serial('session logging writes compact v3 assistant_turn state without cumulative snapshot', async (t) => {
+    const id = persistenceModule.generateId();
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({
+        id,
+        createdAt: '2026-05-26T00:00:00.000Z',
+        projectPath: '/workspace/v3',
+        model: 'gpt-5',
+        provider: 'openai',
+    });
+    const stream = new MockStream();
+    stream.output = [
+        {
+            role: 'assistant',
+            type: 'message',
+            status: 'completed',
+            content: [{ type: 'output_text', text: 'Done.' }],
+        },
+    ];
+    const session = new ConversationSession(id, {
+        agentClient: {
+            startStream: async () => stream,
+            getProvider: () => 'openai',
+        },
+        deps: {
+            logger: stubLogger,
+            settingsService: createMockSettingsService({
+                'agent.model': 'gpt-5',
+                'agent.provider': 'openai',
+            }),
+        },
+        sessionStartedAt: '2026-05-26T00:00:00.000Z',
+    });
+    session.setLogSink((event) => writer.append(event));
+    const result = await session.sendMessage('hello');
+    t.is(result.type, 'response');
+    await writer.close();
+    const filePath = path.join(testDir, `${id}.jsonl`);
+    const envelopes = fs
+        .readFileSync(filePath, 'utf-8')
+        .trim()
+        .split('\n')
+        .map((line) => JSON.parse(line));
+    const turnEnvelope = envelopes.find((env) => env.event?.type === 'assistant_turn');
+    t.truthy(turnEnvelope);
+    t.is(turnEnvelope.v, 3);
+    t.deepEqual(turnEnvelope.event.state, {
+        previousResponseId: 'resp-v3',
+        model: 'gpt-5',
+        provider: 'openai',
+    });
+    t.is(turnEnvelope.event.snapshot, undefined);
+    t.is(turnEnvelope.event.turn.items.length, 1);
+    t.is(turnEnvelope.event.turn.items[0].text, 'Done.');
 });
-test.serial('loadConversation: unscoped load (no filters) accepts conversation with sshHost', (t) => {
+test.serial('replay: interrupted v2 logs without assistant_turn still recover from coarse events', (t) => {
     const id = persistenceModule.generateId();
-    const conversation = {
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    writer.append({ type: 'user_message', message: { id: 'u1', sender: 'user', text: 'interrupted' } });
+    writer.append({ type: 'tool_started', toolCallId: 'call-coarse', toolName: 'shell', arguments: 'ls' });
+    writer.append({
+        type: 'command_message',
+        message: {
+            id: 'cmd-coarse',
+            sender: 'command',
+            status: 'completed',
+            command: 'ls',
+            output: 'some files',
+            success: true,
+            callId: 'call-coarse',
+            toolName: 'shell',
+        },
+    });
+    // No assistant_turn written!
+    void writer.close();
+    const restored = persistenceModule.loadConversation(id);
+    t.truthy(restored);
+    t.true(restored.replayWarnings.some((w) => w.includes('interrupted')));
+    t.is(restored.messages.length, 3); // user, command, system interrupted warning
+    t.is(restored.messages[0].sender, 'user');
+    t.is(restored.messages[1].sender, 'command');
+    t.is(restored.messages[1].status, 'completed');
+    t.is(restored.messages[2].sender, 'system');
+});
+test.serial('session logging with auto-approved tool continuation writes only one assistant_turn containing all details', async (t) => {
+    const id = persistenceModule.generateId();
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({
         id,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        sshHost: 'myhost.example.com',
-        projectPath: '/workspace/alpha',
-        previousResponseId: null,
-        history: [],
-        messages: [{ id: 'msg-1', sender: 'user', text: 'hello' }],
+        createdAt: '2026-05-26T00:00:00.000Z',
+        projectPath: '/workspace/autoapprove',
+        model: 'gpt-5',
+        provider: 'openai',
+    });
+    const stream1 = new MockStream();
+    stream1.state = {
+        approve: () => { },
+    };
+    stream1.interruptions = [
+        {
+            name: 'shell',
+            arguments: { command: 'echo hello' },
+            callId: 'call-1',
+            agent: { name: 'Agent' },
+        },
+    ];
+    let continueCalled = false;
+    const mockAgentClient = {
+        getProvider: () => 'openai',
+        startStream: async () => stream1,
+        continueRunStream: async () => {
+            continueCalled = true;
+            const stream2 = new MockStream();
+            stream2.newItems = [
+                {
+                    type: 'function_call',
+                    callId: 'call-1',
+                    name: 'shell',
+                    arguments: { command: 'echo hello' },
+                },
+                {
+                    type: 'function_call_result',
+                    callId: 'call-1',
+                    name: 'shell',
+                    output: 'hello\n',
+                },
+                {
+                    role: 'assistant',
+                    type: 'message',
+                    content: [{ type: 'output_text', text: 'Done continuation.' }],
+                },
+            ];
+            stream2.output = [
+                {
+                    role: 'assistant',
+                    type: 'message',
+                    status: 'completed',
+                    content: [{ type: 'output_text', text: 'Done continuation.' }],
+                },
+            ];
+            return stream2;
+        },
+    };
+    const session = new ConversationSession(id, {
+        agentClient: mockAgentClient,
+        deps: {
+            logger: stubLogger,
+            settingsService: createMockSettingsService({
+                'agent.model': 'gpt-5',
+                'agent.provider': 'openai',
+            }),
+        },
+        sessionStartedAt: '2026-05-26T00:00:00.000Z',
+    });
+    // Inject a mock shellAutoApproval resolver that auto-approves
+    session.shellAutoApproval = {
+        resolveAdvisoryForInterruption: async () => ({ model: 'gpt-5', reasoning: 'allow', decision: 'approve' }),
+        shouldAutoApprove: () => true,
+        clearCache: () => { },
     };
-    persistenceModule.saveConversation(conversation);
-    // No filters at all — should pass through
-    const loaded = persistenceModule.loadConversation(id);
-    t.truthy(loaded);
-    t.is(loaded.id, id);
-    t.is(loaded.sshHost, 'myhost.example.com');
+    session.setLogSink((event) => writer.append(event));
+    const result = await session.sendMessage('hello');
+    t.is(result.type, 'response');
+    t.true(continueCalled);
+    await writer.close();
+    // Read raw file contents to check what was written to disk
+    const filePath = path.join(testDir, `${id}.jsonl`);
+    const envelopes = fs
+        .readFileSync(filePath, 'utf-8')
+        .trim()
+        .split('\n')
+        .map((line) => JSON.parse(line));
+    const assistantTurnEnvelopes = envelopes.filter((env) => env.event?.type === 'assistant_turn');
+    // Verify that EXACTLY one assistant_turn event was logged!
+    t.is(assistantTurnEnvelopes.length, 1);
+    const turnEvent = assistantTurnEnvelopes[0].event;
+    t.truthy(turnEvent);
+    t.is(turnEvent.turn.items.length, 3); // tool_call, tool_result, assistant_text
+    t.is(turnEvent.turn.items[0].type, 'tool_call');
+    t.is(turnEvent.turn.items[0].callId, 'call-1');
+    t.is(turnEvent.turn.items[1].type, 'tool_result');
+    t.is(turnEvent.turn.items[1].callId, 'call-1');
+    t.is(turnEvent.turn.items[2].type, 'assistant_text');
+    t.is(turnEvent.turn.items[2].text, 'Done continuation.');
 });
 //# sourceMappingURL=conversation-persistence.test.js.map