fix parser replay and multi-db handling

Author: yigitkonur

src/__tests__/gemini-parser.test.ts

@@ -189,9 +189,9 @@ describe('gemini parser hardening', () => {
       'Interim answer that should be rewound away',
     );
     expect(context.filesModified).toContain('login.ts');
-    expect(context.sessionNotes?.tokenUsage).toEqual({ input: 120, output: 30 });
-    expect(context.sessionNotes?.cacheTokens).toEqual({ creation: 0, read: 8 });
-    expect(context.sessionNotes?.thinkingTokens).toBe(6);
+    expect(context.sessionNotes?.tokenUsage).toEqual({ input: 70, output: 20 });
+    expect(context.sessionNotes?.cacheTokens).toEqual({ creation: 0, read: 5 });
+    expect(context.sessionNotes?.thinkingTokens).toBe(4);
     expect(context.sessionNotes?.model).toBe('gemini-2.5-pro');
   });
 
@@ -230,4 +230,35 @@ describe('gemini parser hardening', () => {
     expect(sessions[0].id).toBe('gemini-legacy-session');
     expect(sessions[0].summary).toBe('Handle the fallback path');
   });
+
+  it('skips malformed trailing JSONL lines instead of discarding the whole session', async () => {
+    const home = makeGeminiHome();
+    const filePath = writeGeminiJsonlSession({
+      home,
+      projectId: 'proj-short-id',
+      fileName: 'session-2026-04-15T10-00-malformed1234.jsonl',
+      projects: { '/tmp/gemini-project': 'proj-short-id' },
+      records: [
+        {
+          sessionId: 'gemini-malformed-session',
+          projectHash: 'proj-short-id',
+          startTime: '2026-04-15T10:00:00.000Z',
+          lastUpdated: '2026-04-15T10:00:00.000Z',
+        },
+        {
+          id: 'msg-user-1',
+          timestamp: '2026-04-15T10:00:01.000Z',
+          type: 'user',
+          content: [{ type: 'text', text: 'Parser should survive a bad tail line' }],
+        },
+      ],
+    });
+    fs.appendFileSync(filePath, '{"broken":\n', 'utf8');
+
+    const { parseGeminiSessions } = await loadGeminiParser(home);
+    const sessions = await parseGeminiSessions();
+
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0].id).toBe('gemini-malformed-session');
+  });
 });

src/__tests__/opencode.test.ts

@@ -346,6 +346,38 @@ describe('OpenCode parser', () => {
     }
   });
 
+  it('discovers sessions from channel DBs even when the default opencode.db also exists', async () => {
+    const defaultFixture = createOpenCodeSqliteFixture('opencode.db', {
+      sessionId: 'ses_default',
+      sessionTitle: 'Default DB session',
+    });
+    const channelFixture = createOpenCodeChannelSqliteFixture('opencode-preview.db', {
+      sessionId: 'ses_preview',
+      sessionTitle: 'Preview DB session',
+    });
+
+    try {
+      const mergedRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'opencode-parser-merged-'));
+      const xdgDataHome = path.join(mergedRoot, 'xdg-data');
+      const dbDir = path.join(xdgDataHome, 'opencode');
+      fs.mkdirSync(dbDir, { recursive: true });
+      fs.copyFileSync(defaultFixture.dbPath, path.join(dbDir, 'opencode.db'));
+      fs.copyFileSync(channelFixture.dbPath, path.join(dbDir, 'opencode-preview.db'));
+
+      process.env.XDG_DATA_HOME = xdgDataHome;
+      process.env.OPENCODE_DB = '';
+
+      const { parseOpenCodeSessions } = await importOpenCodeParser();
+      const sessions = await parseOpenCodeSessions();
+
+      expect(sessions.map((session) => session.id)).toContain('ses_default');
+      expect(sessions.map((session) => session.id)).toContain('ses_preview');
+    } finally {
+      defaultFixture.cleanup();
+      channelFixture.cleanup();
+    }
+  });
+
   it('keeps high-value non-text SQLite parts in extracted recent messages', async () => {
     const fixture = createOpenCodeSqliteFixture('opencode.db', {
       sessionId: 'ses_parts',

src/parsers/gemini.ts

@@ -126,6 +126,7 @@ async function parseJsonlSessionFile(filePath: string): Promise<GeminiSessionDat
   const rl = readline.createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
   const sessionState: Partial<GeminiSessionData> = {};
   const messages: GeminiMessage[] = [];
+  const messageIndexById = new Map<string, number>();
 
   try {
     for await (const rawLine of rl) {
@@ -136,8 +137,8 @@ async function parseJsonlSessionFile(filePath: string): Promise<GeminiSessionDat
       try {
         record = JSON.parse(line) as GeminiJsonlRecord;
       } catch (err) {
-        logger.debug('gemini: invalid JSONL record', filePath, err);
-        return null;
+        logger.debug('gemini: skipping malformed JSONL record', filePath, err);
+        continue;
       }
 
       if (record.$set && typeof record.$set === 'object') {
@@ -149,13 +150,28 @@ async function parseJsonlSessionFile(filePath: string): Promise<GeminiSessionDat
         const rewindIndex = findRewindIndex(messages, record.$rewindTo);
         if (rewindIndex >= 0) {
           messages.length = rewindIndex;
+          for (const [messageId, index] of messageIndexById.entries()) {
+            if (index >= rewindIndex) {
+              messageIndexById.delete(messageId);
+            }
+          }
         }
         continue;
       }
 
       const message = toGeminiMessage(record);
       if (message) {
-        messages.push(message);
+        if (message.id) {
+          const existingIndex = messageIndexById.get(message.id);
+          if (existingIndex !== undefined) {
+            messages[existingIndex] = message;
+          } else {
+            messageIndexById.set(message.id, messages.length);
+            messages.push(message);
+          }
+        } else {
+          messages.push(message);
+        }
         continue;
       }