@qduc/term2 0.6.0 → 0.7.0

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

@@ -3,18 +3,23 @@ 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';
 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: [] };
 }
 test.beforeEach(() => {
     testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'term2-conversations-test-'));
@@ -30,389 +35,514 @@ 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';
-    const cmd = persistenceModule.getResumeCommand(id);
-    t.is(cmd, 'term2 --resume test-uuid-123');
+    t.is(persistenceModule.getResumeCommand(id), 'term2 --resume test-uuid-123');
+    t.is(persistenceModule.getResumeCommand(id, 'user@host'), 'term2 --ssh user@host --resume test-uuid-123');
+    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('saveConversation: creates file and last.json pointer', (t) => {
+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_final',
+        message: { id: 'b1', sender: 'bot', status: 'finalized', text: 'hi there' },
+        finalText: 'hi there',
+        snapshot: {
+            history: [
+                { role: 'user', type: 'message', content: 'hello' },
+                { role: 'assistant', type: 'message', content: 'hi there' },
+            ],
+            previousResponseId: 'resp-1',
+            toolLedger: [],
+            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({
+        type: 'assistant_final',
+        message: { id: 'b1', sender: 'bot', status: 'finalized', text: 'done' },
+        finalText: 'done',
+        snapshot: {
+            history: [{ role: 'user', type: 'message', content: 'do it' }],
+            previousResponseId: 'r1',
+            toolLedger: [],
+        },
+    });
+    // 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')));
+    // Recovery system message present in history
+    const hasRecovery = restored.history.some((item) => item?.role === 'system' && typeof item.content === 'string' && item.content.includes('Recovered'));
+    t.true(hasRecovery);
+    // 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_final 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('loadConversation: returns null for non-existent id', (t) => {
-    const result = persistenceModule.loadConversation('non-existent-id');
-    t.is(result, null);
-});
-test.serial('loadConversation: returns saved conversation', (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(),
-        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: preserves saved app mode settings', (t) => {
+    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_final',
+        message: { id: 'b1', sender: 'bot', status: 'finalized', text: 'ok' },
+        finalText: 'ok',
+        snapshot: { history: [], previousResponseId: null, toolLedger: [], model: 'gpt-5' },
+    });
+    void writer.close();
+    const restored = persistenceModule.loadConversation(id);
+    t.is(restored.model, 'gpt-5');
+});
+test.serial('replay: undo with snapshot replaces state', (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,
+    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({
+        type: 'assistant_final',
+        message: { id: 'b1', sender: 'bot', status: 'finalized', text: 'A' },
+        finalText: 'A',
+        snapshot: {
+            history: [{ role: 'user', type: 'message', content: 'first' }],
+            previousResponseId: 'r1',
+            toolLedger: [],
+        },
+    });
+    writer.append({ type: 'user_message', message: { id: 'u2', sender: 'user', text: 'second' } });
+    writer.append({
+        type: 'assistant_final',
+        message: { id: 'b2', sender: 'bot', status: 'finalized', text: 'B' },
+        finalText: 'B',
+        snapshot: {
+            history: [{ role: 'user', type: 'message', content: 'first' }],
+            previousResponseId: 'r2',
+            toolLedger: [],
         },
-        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,
     });
+    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('loadConversation: returns null when saved project path differs from expected path', (t) => {
+test.serial('replay: corrupt line is skipped', (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);
-});
-test.serial('loadConversationForProject: reports project mismatch for existing conversation in another path', (t) => {
+    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 goodFinal = JSON.stringify({
+        v: 1,
+        seq: 3,
+        ts: '2026-05-26T00:00:01.000Z',
+        event: {
+            type: 'assistant_final',
+            message: { id: 'b1', sender: 'bot', status: 'finalized', text: 'ok' },
+            finalText: 'ok',
+            snapshot: { history: [], previousResponseId: 'r1', toolLedger: [] },
+        },
+    });
+    fs.writeFileSync(filePath, `${goodInit}\n{not json\n${goodFinal}\n`, 'utf-8');
+    const restored = persistenceModule.loadConversation(id);
+    t.is(restored.previousResponseId, 'r1');
+});
+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 result = persistenceModule.loadConversationForProject(id, '/workspace/beta');
-    t.is(result.status, 'project_mismatch');
-    if (result.status !== 'project_mismatch') {
-        t.fail('expected project_mismatch');
-        return;
-    }
-    t.is(result.conversation.id, id);
+    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('lock: released on writer close, second writer succeeds', async (t) => {
+    const id = persistenceModule.generateId();
+    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('loadConversationForProject: reports not_found for missing conversation', (t) => {
-    const result = persistenceModule.loadConversationForProject('missing-id', '/workspace/beta');
-    t.is(result.status, 'not_found');
+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({
+        type: 'assistant_final',
+        message: { id: 'b1', sender: 'bot', status: 'finalized', text: 'A' },
+        finalText: 'A',
+        snapshot: {
+            history: [{ role: 'user', type: 'message', content: 'hi' }],
+            previousResponseId: 'r1',
+            toolLedger: [],
+        },
+    });
+    void writer.close();
+    t.true(persistenceModule.forkConversation(srcId, dstId));
+    const restored = persistenceModule.loadConversation(dstId);
+    t.is(restored.previousResponseId, 'r1');
 });
-test.serial('loadConversation: returns saved conversation when expected project path matches', (t) => {
+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 */
+    }
+    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 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);
-});
-test.serial('loadConversation: unscoped loads keep backward-compatible behavior', (t) => {
+    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('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);
-});
-test.serial('loadLastConversation: returns null when no last.json exists', (t) => {
-    const result = persistenceModule.loadLastConversation();
-    t.is(result, null);
-});
-test.serial('loadLastConversation: returns the last saved conversation', (t) => {
+    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('loadConversationForProject: not_found for missing', (t) => {
+    t.is(persistenceModule.loadConversationForProject('missing', '/x').status, 'not_found');
+});
+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: 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' }],
+});
+test.serial('loadLastConversation: does not save last.json for empty conversation', (t) => {
+    const id = persistenceModule.generateId();
+    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.is(last, null);
+    t.false(fs.existsSync(path.join(testDir, 'last.json')));
+});
+test.serial('hasConversationContent: returns false for missing conversation', (t) => {
+    t.false(persistenceModule.hasConversationContent('non-existent-id'));
+});
+test.serial('hasConversationContent: returns false for empty conversation', (t) => {
+    const id = persistenceModule.generateId();
+    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('hasConversationContent: returns true for user_message', (t) => {
+    const id = persistenceModule.generateId();
+    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('hasConversationContent: returns true for assistant_final', (t) => {
+    const id = persistenceModule.generateId();
+    const writer = createConversationLogWriter({ sessionId: id, dir: testDir, logger: stubLogger });
+    writer.init({ id, createdAt: '2026-05-26T00:00:00.000Z' });
+    writer.append({
+        type: 'assistant_final',
+        message: { id: 'a1', sender: 'bot', status: 'finalized', text: 'hello' },
+        finalText: 'hello',
+        snapshot: emptySnapshot(),
     });
-    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' }],
+    void writer.close();
+    t.true(persistenceModule.hasConversationContent(id));
+});
+test.serial('hasConversationContent: skips corrupt lines and finds content', (t) => {
+    const id = persistenceModule.generateId();
+    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 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 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'],
+                },
+            },
+        },
     });
-    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' }],
+    // 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' } },
+        }),
     });
-    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' }],
+    // 3. Log assistant_final event with nestedRunResult in snapshot
+    writer.append({
+        type: 'assistant_final',
+        message: { id: 'b1', sender: 'bot', status: 'finalized', text: 'all done' },
+        finalText: 'all done',
+        snapshot: {
+            history: [
+                {
+                    role: 'tool',
+                    type: 'function_call_result',
+                    name: 'run_subagent',
+                    output: JSON.stringify({
+                        status: 'completed',
+                        finalText: 'Snapshot result text',
+                        nestedRunResult: { state: { internalStuff: 'hidden' } },
+                    }),
+                },
+            ],
+            previousResponseId: 'resp-1',
+            toolLedger: [
+                {
+                    turnId: 'turn-1',
+                    callId: 'call-subagent-1',
+                    toolName: 'run_subagent',
+                    status: 'completed',
+                    startedAt: '2026-05-26T00:00:00.000Z',
+                    output: {
+                        status: 'completed',
+                        nestedRunResult: { state: { internalStuff: 'hidden' } },
+                    },
+                },
+            ],
+        },
     });
-    const last = persistenceModule.loadLastConversation('/workspace/beta');
-    t.is(last, null);
+    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_final and check snapshot
+    const finalEnv = envelopes.find((env) => env.event?.type === 'assistant_final');
+    t.truthy(finalEnv);
+    const snapHistoryOutput = JSON.parse(finalEnv.event.snapshot.history[0].output);
+    t.is(snapHistoryOutput.status, 'completed');
+    t.is(snapHistoryOutput.finalText, 'Snapshot result text');
+    t.is(snapHistoryOutput.nestedRunResult, undefined);
+    t.is(finalEnv.event.snapshot.toolLedger[0].output.status, 'completed');
+    t.is(finalEnv.event.snapshot.toolLedger[0].output.nestedRunResult, undefined);
 });
-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('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('loadConversation: old save without orchestratorMode — resolves to false, no error', (t) => {
+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();
-    // 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 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('loadLastConversation: migrates old last.json format', (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 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('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 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 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;
 //# sourceMappingURL=conversation-persistence.test.js.map