@selesai/code 0.13.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/tests/store/session-indexer.test.ts

@@ -0,0 +1,643 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { DatabaseManager } from '../../src/store/db.js';
+import {
+  indexSession,
+  indexAllSessions,
+  indexChangedSessions,
+  getSessionStats,
+  countSessionFiles,
+  needsBackfill,
+  touchBackfillTimestamp,
+  LAST_SESSION_BACKFILL_KEY,
+  indexCurrentSession,
+  indexLiveSession,
+  parseSessionManagerSnapshot,
+  truncateMessageContent,
+  upsertSessionFileMetadata,
+  pruneEphemeralReviewSessions,
+} from '../../src/store/session-indexer.js';
+import { DEFAULT_MAX_MESSAGE_CONTENT_LENGTH } from '../../src/constants.js';
+import { parseSessionFile, type ParsedSession } from '../../src/store/session-parser.js';
+
+describe('session-indexer', () => {
+  let tmpDir: string;
+  let dbManager: DatabaseManager;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'indexer-test-'));
+    dbManager = new DatabaseManager(tmpDir);
+  });
+
+  afterEach(() => {
+    dbManager.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createTestSession(overrides: Partial<ParsedSession> = {}): ParsedSession {
+    const id = overrides.id ?? 'session-1';
+    return {
+      id,
+      project: 'test-project',
+      cwd: '/test',
+      startedAt: '2026-05-03T00:00:00Z',
+      endedAt: null,
+      messages: [
+        { id: `${id}-msg-1`, role: 'user', content: 'Hello', timestamp: '2026-05-03T00:01:00Z' },
+        { id: `${id}-msg-2`, role: 'assistant', content: 'Hi there!', timestamp: '2026-05-03T00:01:30Z', toolCalls: ['read'] },
+      ],
+      ...overrides,
+    };
+  }
+
+  describe('indexSession', () => {
+    it('should index a session and its messages', () => {
+      const session = createTestSession();
+      const result = indexSession(dbManager, session);
+
+      assert.strictEqual(result.sessionId, 'session-1');
+      assert.strictEqual(result.messagesIndexed, 2);
+      assert.strictEqual(result.skipped, false);
+
+      // Verify in database
+      const db = dbManager.getDb();
+      const dbSession = db.prepare('SELECT * FROM sessions WHERE id = ?').get('session-1') as Record<string, unknown>;
+      assert.strictEqual(dbSession.project, 'test-project');
+      assert.strictEqual(dbSession.message_count, 2);
+
+      const messages = db.prepare('SELECT * FROM messages WHERE session_id = ?').all('session-1') as Record<string, unknown>[];
+      assert.strictEqual(messages.length, 2);
+      assert.strictEqual(messages[0].role, 'user');
+      assert.strictEqual(messages[1].role, 'assistant');
+    });
+
+    it('should store tool_calls as JSON', () => {
+      const session = createTestSession();
+      indexSession(dbManager, session);
+
+      const db = dbManager.getDb();
+      const msg = db.prepare('SELECT tool_calls FROM messages WHERE id = ?').get('session-1-msg-2') as { tool_calls: string | null };
+      assert.ok(msg.tool_calls);
+      assert.deepStrictEqual(JSON.parse(msg.tool_calls), ['read']);
+    });
+
+    it('should cap oversized message content while retaining both ends', () => {
+      const content = `begin-${'x'.repeat(DEFAULT_MAX_MESSAGE_CONTENT_LENGTH)}-end`;
+      const session = createTestSession({
+        messages: [{ id: 'oversized-message', role: 'assistant', content, timestamp: '2026-05-03T00:01:00Z' }],
+      });
+
+      indexSession(dbManager, session);
+
+      const stored = dbManager.getDb().prepare('SELECT content FROM messages WHERE id = ?').get('oversized-message') as { content: string };
+      assert.ok(stored.content.length <= DEFAULT_MAX_MESSAGE_CONTENT_LENGTH);
+      assert.match(stored.content, /^begin-/);
+      assert.match(stored.content, /-end$/);
+      assert.match(stored.content, /truncated, \d+ chars total/);
+      assert.strictEqual(truncateMessageContent('short content'), 'short content');
+    });
+
+    it('should skip already-indexed sessions with no new messages', () => {
+      const session = createTestSession();
+
+      const result1 = indexSession(dbManager, session);
+      assert.strictEqual(result1.skipped, false);
+
+      const result2 = indexSession(dbManager, session);
+      assert.strictEqual(result2.skipped, true);
+      assert.strictEqual(result2.messagesIndexed, 0);
+    });
+
+    it('should append missing messages for an already-indexed resumed session', () => {
+      const session = createTestSession();
+      indexSession(dbManager, session);
+
+      const resumed = createTestSession({
+        messages: [
+          ...session.messages,
+          { id: 'session-1-msg-3', role: 'user', content: 'Resumed later', timestamp: '2026-05-03T00:02:00Z' },
+        ],
+      });
+      const result = indexSession(dbManager, resumed);
+
+      assert.strictEqual(result.skipped, false);
+      assert.strictEqual(result.messagesIndexed, 1);
+      assert.strictEqual(dbManager.getStats().sessions, 1);
+      assert.strictEqual(dbManager.getStats().messages, 3);
+
+      const dbSession = dbManager.getDb().prepare('SELECT message_count FROM sessions WHERE id = ?').get('session-1') as { message_count: number };
+      assert.strictEqual(dbSession.message_count, 3);
+    });
+
+    it('should handle sessions with no messages', () => {
+      const session = createTestSession({ messages: [] });
+      const result = indexSession(dbManager, session);
+
+      assert.strictEqual(result.messagesIndexed, 0);
+      assert.strictEqual(result.skipped, false);
+    });
+  });
+
+  describe('indexAllSessions', () => {
+    it('should index all JSONL files from disk', () => {
+      // Create mock session directory structure
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      const projDir = path.join(sessionsDir, 'test-project');
+      fs.mkdirSync(projDir, { recursive: true });
+
+      // Write a valid JSONL file
+      const lines = [
+        JSON.stringify({ type: 'session', id: 's1', timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+        JSON.stringify({
+          type: 'message',
+          id: 'm1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: [{ type: 'text', text: 'Hello' }], timestamp: Date.now() },
+        }),
+      ];
+      fs.writeFileSync(path.join(projDir, 'session1.jsonl'), lines.join('\n'));
+
+      const result = indexAllSessions(dbManager, sessionsDir);
+      assert.strictEqual(result.sessionsProcessed, 1);
+      assert.strictEqual(result.sessionsIndexed, 1);
+      assert.strictEqual(result.messagesIndexed, 1);
+      assert.strictEqual(result.errors.length, 0);
+    });
+
+    it('should skip already-indexed sessions on re-run', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      const projDir = path.join(sessionsDir, 'test-project');
+      fs.mkdirSync(projDir, { recursive: true });
+
+      const lines = [
+        JSON.stringify({ type: 'session', id: 's1', timestamp: '2026-05-03T00:00:00Z', cwd: '/test' }),
+        JSON.stringify({
+          type: 'message',
+          id: 'm1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: [{ type: 'text', text: 'Hello' }], timestamp: Date.now() },
+        }),
+      ];
+      fs.writeFileSync(path.join(projDir, 'session1.jsonl'), lines.join('\n'));
+
+      // First run
+      const result1 = indexAllSessions(dbManager, sessionsDir);
+      assert.strictEqual(result1.sessionsIndexed, 1);
+
+      // Second run — should skip
+      const result2 = indexAllSessions(dbManager, sessionsDir);
+      assert.strictEqual(result2.sessionsSkipped, 1);
+      assert.strictEqual(result2.sessionsIndexed, 0);
+    });
+
+    it('should handle invalid JSONL files gracefully', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      const projDir = path.join(sessionsDir, 'test-project');
+      fs.mkdirSync(projDir, { recursive: true });
+
+      // Invalid file (no session entry)
+      fs.writeFileSync(path.join(projDir, 'invalid.jsonl'), '{"type":"message","id":"m1"}');
+
+      const result = indexAllSessions(dbManager, sessionsDir);
+      assert.strictEqual(result.sessionsProcessed, 1);
+      assert.strictEqual(result.errors.length, 1);
+    });
+
+    it('should handle empty sessions directory', () => {
+      const sessionsDir = path.join(tmpDir, 'empty-sessions');
+      fs.mkdirSync(sessionsDir);
+
+      const result = indexAllSessions(dbManager, sessionsDir);
+      assert.strictEqual(result.sessionsProcessed, 0);
+      assert.strictEqual(result.sessionsIndexed, 0);
+    });
+
+    it('should handle non-existent sessions directory', () => {
+      const result = indexAllSessions(dbManager, '/nonexistent/path');
+      assert.strictEqual(result.sessionsProcessed, 0);
+    });
+  });
+
+  describe('indexChangedSessions', () => {
+    function writeJsonlSession(filePath: string, sessionId: string, messageIds = [`${sessionId}-m1`]): void {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      const lines = [
+        JSON.stringify({ type: 'session', id: sessionId, timestamp: '2026-05-03T00:00:00Z', cwd: `/test/${sessionId}` }),
+        ...messageIds.map((id, index) => JSON.stringify({
+          type: 'message',
+          id,
+          parentId: null,
+          timestamp: `2026-05-03T00:0${index + 1}:00Z`,
+          message: { role: 'user', content: [{ type: 'text', text: `Hello ${id}` }], timestamp: Date.now() },
+        })),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+    }
+
+    it('skips unchanged files using stored size and mtime metadata without parsing them', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      const filePath = path.join(sessionsDir, 'project-a', 's1.jsonl');
+      writeJsonlSession(filePath, 's1');
+      indexAllSessions(dbManager, sessionsDir);
+
+      const result = indexChangedSessions(dbManager, sessionsDir);
+
+      assert.strictEqual(result.sessionsProcessed, 0);
+      assert.strictEqual(result.sessionsSkipped, 1);
+      assert.strictEqual(result.errors.length, 0);
+    });
+
+    it('indexes changed files and appends newly persisted messages', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      const filePath = path.join(sessionsDir, 'project-a', 's1.jsonl');
+      writeJsonlSession(filePath, 's1', ['s1-m1']);
+      indexAllSessions(dbManager, sessionsDir);
+
+      writeJsonlSession(filePath, 's1', ['s1-m1', 's1-m2']);
+      const result = indexChangedSessions(dbManager, sessionsDir);
+
+      assert.strictEqual(result.sessionsProcessed, 1);
+      assert.strictEqual(result.sessionsIndexed, 1);
+      assert.strictEqual(result.messagesIndexed, 1);
+      assert.strictEqual(dbManager.getStats().messages, 2);
+    });
+
+    it('parses existing sessions without file metadata and appends missed messages', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      const filePath = path.join(sessionsDir, 'project-a', 's1.jsonl');
+      indexSession(dbManager, createTestSession({
+        id: 's1',
+        messages: [
+          { id: 's1-m1', role: 'user', content: 'Hello s1-m1', timestamp: '2026-05-03T00:01:00Z' },
+        ],
+      }));
+      writeJsonlSession(filePath, 's1', ['s1-m1', 's1-m2']);
+
+      const result = indexChangedSessions(dbManager, sessionsDir);
+
+      assert.strictEqual(result.sessionsProcessed, 1);
+      assert.strictEqual(result.sessionsIndexed, 1);
+      assert.strictEqual(result.messagesIndexed, 1);
+      assert.strictEqual(dbManager.getStats().messages, 2);
+    });
+
+    it('caps parsed files during startup incremental backfill', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(path.join(sessionsDir, 'project-a', 's1.jsonl'), 's1');
+      writeJsonlSession(path.join(sessionsDir, 'project-a', 's2.jsonl'), 's2');
+
+      const result = indexChangedSessions(dbManager, sessionsDir, { maxFilesToIndex: 1 });
+
+      assert.strictEqual(result.sessionsProcessed, 1);
+      assert.strictEqual(result.reachedLimit, true);
+      assert.strictEqual(dbManager.getStats().sessions, 1);
+    });
+
+    it('processes the most recently modified changed files first when the cap is reached', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      // Write an older file first, then a newer one. With newest-first ordering
+      // the newer file must be indexed even when the cap only allows one file.
+      const olderPath = path.join(sessionsDir, 'project-a', 'older.jsonl');
+      const newerPath = path.join(sessionsDir, 'project-a', 'newer.jsonl');
+      writeJsonlSession(olderPath, 'older');
+      // Ensure a measurable mtime gap (some filesystems have coarse mtime resolution).
+      const past = new Date(Date.now() - 60_000);
+      fs.utimesSync(olderPath, past, past);
+      writeJsonlSession(newerPath, 'newer');
+
+      const result = indexChangedSessions(dbManager, sessionsDir, { maxFilesToIndex: 1 });
+
+      assert.strictEqual(result.sessionsProcessed, 1);
+      assert.strictEqual(result.reachedLimit, true);
+      assert.strictEqual(dbManager.getStats().sessions, 1);
+      // The newer file should be the one indexed.
+      const indexed = dbManager.getDb().prepare('SELECT id FROM sessions').all() as { id: string }[];
+      assert.deepStrictEqual(indexed.map((r) => r.id), ['newer']);
+    });
+  });
+
+  describe('current session indexing helpers', () => {
+    function writeSessionFile(filePath: string): void {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      const lines = [
+        JSON.stringify({ type: 'session', id: 'file-session-1', timestamp: '2026-05-03T00:00:00Z', cwd: '/work/file-project' }),
+        JSON.stringify({
+          type: 'message',
+          id: 'file-entry-1',
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: [{ type: 'text', text: 'from persisted file' }], timestamp: Date.now() },
+        }),
+      ];
+      fs.writeFileSync(filePath, lines.join('\n'));
+    }
+
+    function createSessionManagerSnapshot(entries: unknown[] = []) {
+      return {
+        getHeader: () => ({ id: 'live-session-1', timestamp: '2026-05-03T00:00:00Z', cwd: '/work/live-project' }),
+        getEntries: () => entries,
+      };
+    }
+
+    it('parseSessionManagerSnapshot converts current session entries into ParsedSession', () => {
+      const snapshot = createSessionManagerSnapshot([
+        {
+          type: 'message',
+          id: 'entry-1',
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: 'Hello live session' },
+        },
+        {
+          type: 'message',
+          id: 'entry-2',
+          timestamp: '2026-05-03T00:02:00Z',
+          message: { role: 'assistant', content: [{ type: 'text', text: 'Hi' }, { type: 'toolCall', name: 'read' }] },
+        },
+        {
+          type: 'message',
+          id: 'entry-3',
+          timestamp: '2026-05-03T00:03:00Z',
+          message: { role: 'toolResult', content: [{ type: 'text', text: 'tool output is not indexed by current schema' }] },
+        },
+      ]);
+
+      const parsed = parseSessionManagerSnapshot(snapshot);
+
+      assert.ok(parsed);
+      assert.strictEqual(parsed.id, 'live-session-1');
+      assert.strictEqual(parsed.project, 'live-project');
+      assert.strictEqual(parsed.messages.length, 2);
+      assert.deepStrictEqual(parsed.messages[1].toolCalls, ['read']);
+    });
+
+    it('parseSessionManagerSnapshot skips embedded tool result content', () => {
+      const parsed = parseSessionManagerSnapshot(createSessionManagerSnapshot([
+        {
+          type: 'message',
+          id: 'entry-1',
+          timestamp: '2026-05-03T00:01:00Z',
+          message: {
+            role: 'assistant',
+            content: [
+              { type: 'text', text: 'Summary of the result.' },
+              { type: 'tool_result', content: [{ type: 'text', text: 'unbounded output' }] },
+            ],
+          },
+        },
+      ]));
+
+      assert.ok(parsed);
+      assert.strictEqual(parsed.messages[0].content, 'Summary of the result.');
+    });
+
+    it('indexLiveSession prefers the persisted JSONL file when available', () => {
+      const filePath = path.join(tmpDir, 'sessions', 'project', 'file-session.jsonl');
+      writeSessionFile(filePath);
+      const snapshot = {
+        getHeader: () => ({ id: 'stale-memory-session', timestamp: '2026-05-03T00:00:00Z', cwd: '/work/stale' }),
+        getEntries: () => [],
+        getSessionFile: () => filePath,
+      };
+
+      const result = indexLiveSession(dbManager, snapshot);
+
+      assert.ok(result);
+      assert.strictEqual(result.sessionId, 'file-session-1');
+      assert.strictEqual(result.messagesIndexed, 1);
+      const indexed = dbManager.getDb().prepare('SELECT id, cwd FROM sessions WHERE id = ?').get('file-session-1') as { id: string; cwd: string };
+      assert.strictEqual(indexed.cwd, '/work/file-project');
+    });
+
+    it('does not index a session without persisted file provenance', () => {
+      const result = indexLiveSession(dbManager, {
+        getHeader: () => ({ id: 'ephemeral-review', timestamp: '2026-05-03T00:00:00Z', cwd: '/tmp/review' }),
+        getEntries: () => [{
+          type: 'message',
+          id: 'review-message',
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: [{ type: 'text', text: 'review prompt' }] },
+        }],
+        getSessionFile: () => undefined,
+      });
+
+      assert.strictEqual(result, null);
+      assert.strictEqual(dbManager.getStats().sessions, 0);
+      assert.strictEqual(dbManager.getStats().messages, 0);
+    });
+
+    it('removes existing file-less background review sessions', () => {
+      indexSession(dbManager, {
+        id: 'old-background-review',
+        project: 'review',
+        cwd: '/tmp/review',
+        startedAt: '2026-05-03T00:00:00Z',
+        endedAt: null,
+        messages: [{
+          id: 'review-message',
+          role: 'user',
+          content: '<file name="/tmp/pi-hermes-prompt-abc123/prompt.md">\nReview the conversation above.',
+          timestamp: '2026-05-03T00:01:00Z',
+        }],
+      });
+
+      assert.strictEqual(pruneEphemeralReviewSessions(dbManager), 1);
+      assert.strictEqual(dbManager.getStats().sessions, 0);
+      assert.strictEqual(dbManager.getStats().messages, 0);
+    });
+
+    it('indexCurrentSession indexes missing live messages idempotently', () => {
+      const entries = [
+        {
+          type: 'message',
+          id: 'entry-1',
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: 'Hello live session' },
+        },
+      ];
+      const snapshot = createSessionManagerSnapshot(entries);
+
+      const result1 = indexCurrentSession(dbManager, snapshot);
+      assert.ok(result1);
+      assert.strictEqual(result1.messagesIndexed, 1);
+      assert.strictEqual(dbManager.getStats().sessions, 1);
+      assert.strictEqual(dbManager.getStats().messages, 1);
+
+      entries.push({
+        type: 'message',
+        id: 'entry-2',
+        timestamp: '2026-05-03T00:02:00Z',
+        message: { role: 'assistant', content: [{ type: 'text', text: 'Hi again' }] },
+      });
+      const result2 = indexCurrentSession(dbManager, snapshot);
+      assert.ok(result2);
+      assert.strictEqual(result2.messagesIndexed, 1);
+      assert.strictEqual(dbManager.getStats().sessions, 1);
+      assert.strictEqual(dbManager.getStats().messages, 2);
+
+      const result3 = indexCurrentSession(dbManager, snapshot);
+      assert.ok(result3);
+      assert.strictEqual(result3.skipped, true);
+      assert.strictEqual(result3.messagesIndexed, 0);
+    });
+  });
+
+  describe('backfill metadata helpers', () => {
+    function writeJsonlSession(sessionsDir: string, projectDir: string, sessionId: string): void {
+      const projDir = path.join(sessionsDir, projectDir);
+      fs.mkdirSync(projDir, { recursive: true });
+      const lines = [
+        JSON.stringify({ type: 'session', id: sessionId, timestamp: '2026-05-03T00:00:00Z', cwd: `/test/${projectDir}` }),
+        JSON.stringify({
+          type: 'message',
+          id: `${sessionId}-m1`,
+          parentId: null,
+          timestamp: '2026-05-03T00:01:00Z',
+          message: { role: 'user', content: [{ type: 'text', text: 'Hello' }], timestamp: Date.now() },
+        }),
+      ];
+      fs.writeFileSync(path.join(projDir, `${sessionId}.jsonl`), lines.join('\n'));
+    }
+
+    it('countSessionFiles counts JSONL files in session project directories', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      writeJsonlSession(sessionsDir, 'project-b', 's2');
+      fs.writeFileSync(path.join(sessionsDir, 'project-b', 'notes.txt'), 'not a session');
+
+      assert.strictEqual(countSessionFiles(sessionsDir), 2);
+    });
+
+    it('needsBackfill is true when session file count exceeds indexed sessions', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z')), true);
+    });
+
+    it('needsBackfill is false when counts match and timestamp is recent', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      indexAllSessions(dbManager, sessionsDir);
+      touchBackfillTimestamp(dbManager, new Date('2026-05-03T00:30:00Z'));
+
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z')), false);
+    });
+
+    it('needsBackfill is true when file metadata changes even with a recent timestamp', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      indexAllSessions(dbManager, sessionsDir);
+      touchBackfillTimestamp(dbManager, new Date('2026-05-03T00:30:00Z'));
+
+      fs.appendFileSync(path.join(sessionsDir, 'project-a', 's1.jsonl'), '\n' + JSON.stringify({
+        type: 'message',
+        id: 's1-m2',
+        parentId: null,
+        timestamp: '2026-05-03T00:02:00Z',
+        message: { role: 'user', content: [{ type: 'text', text: 'Hello again' }], timestamp: Date.now() },
+      }));
+
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z')), true);
+    });
+
+    it('needsBackfill is true for existing sessions without file metadata even with a recent timestamp', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      indexSession(dbManager, createTestSession({ id: 's1', messages: [] }));
+      touchBackfillTimestamp(dbManager, new Date('2026-05-03T00:30:00Z'));
+
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z')), true);
+    });
+
+    it('needsBackfill is true when timestamp is missing or older than 24 hours', () => {
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      indexAllSessions(dbManager, sessionsDir);
+
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z')), true);
+
+      touchBackfillTimestamp(dbManager, new Date('2026-05-01T00:00:00Z'));
+      assert.strictEqual(needsBackfill(dbManager, sessionsDir, new Date('2026-05-03T01:00:00Z')), true);
+    });
+
+    it('touchBackfillTimestamp upserts the metadata row', () => {
+      touchBackfillTimestamp(dbManager, new Date('2026-05-03T00:00:00Z'));
+      touchBackfillTimestamp(dbManager, new Date('2026-05-03T01:00:00Z'));
+
+      const row = dbManager.getDb().prepare('SELECT value FROM extension_metadata WHERE key = ?').get(LAST_SESSION_BACKFILL_KEY) as { value: string };
+      assert.strictEqual(row.value, '2026-05-03T01:00:00.000Z');
+    });
+
+    it('upsertSessionFileMetadata keeps stored metadata in sync after a session file is appended', () => {
+      // Mirrors the session_shutdown path: index the session, then upsert the
+      // file metadata for the final on-disk state. A subsequent
+      // indexChangedSessions pass must skip the file instead of re-parsing it.
+      const sessionsDir = path.join(tmpDir, 'sessions');
+      writeJsonlSession(sessionsDir, 'project-a', 's1');
+      const filePath = path.join(sessionsDir, 'project-a', 's1.jsonl');
+
+      indexAllSessions(dbManager, sessionsDir);
+      // Simulate Pi appending the closing entry on shutdown.
+      fs.appendFileSync(filePath, '\n' + JSON.stringify({
+        type: 'message',
+        id: 's1-m2',
+        parentId: null,
+        timestamp: '2026-05-03T00:02:00Z',
+        message: { role: 'user', content: [{ type: 'text', text: 'Hello again' }], timestamp: Date.now() },
+      }));
+      const session = parseSessionFile(filePath);
+      indexSession(dbManager, session);
+      upsertSessionFileMetadata(dbManager, filePath, session.id);
+
+      const result = indexChangedSessions(dbManager, sessionsDir);
+
+      assert.strictEqual(result.sessionsProcessed, 0);
+      assert.strictEqual(result.sessionsSkipped, 1);
+      assert.strictEqual(result.reachedLimit, undefined);
+    });
+  });
+
+  describe('getSessionStats', () => {
+    it('should return zero counts for empty database', () => {
+      const stats = getSessionStats(dbManager);
+      assert.strictEqual(stats.totalSessions, 0);
+      assert.strictEqual(stats.totalMessages, 0);
+      assert.deepStrictEqual(stats.projects, []);
+    });
+
+    it('should return correct stats after indexing', () => {
+      const session = createTestSession();
+      indexSession(dbManager, session);
+
+      const stats = getSessionStats(dbManager);
+      assert.strictEqual(stats.totalSessions, 1);
+      assert.strictEqual(stats.totalMessages, 2);
+      assert.strictEqual(stats.projects.length, 1);
+      assert.strictEqual(stats.projects[0].project, 'test-project');
+      assert.strictEqual(stats.projects[0].sessions, 1);
+      assert.strictEqual(stats.projects[0].messages, 2);
+    });
+
+    it('should group by project', () => {
+      indexSession(dbManager, createTestSession({ id: 's1', project: 'project-a' }));
+      indexSession(dbManager, createTestSession({ id: 's2', project: 'project-a' }));
+      indexSession(dbManager, createTestSession({ id: 's3', project: 'project-b' }));
+
+      const stats = getSessionStats(dbManager);
+      assert.strictEqual(stats.totalSessions, 3);
+      assert.strictEqual(stats.projects.length, 2);
+
+      const projA = stats.projects.find(p => p.project === 'project-a');
+      const projB = stats.projects.find(p => p.project === 'project-b');
+      assert.ok(projA);
+      assert.ok(projB);
+      assert.strictEqual(projA.sessions, 2);
+      assert.strictEqual(projB.sessions, 1);
+    });
+  });
+});