/**
 * Unit Tests for MemoryHookService
 *
 * @module @agentkits/memory/hooks/__tests__/service
 */

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { existsSync, rmSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
import * as path from 'node:path';
import { MemoryHookService, createHookService } from '../service.js';
import { _setRunClaudePrintMockForTesting, resetAIEnrichmentCache } from '../ai-enrichment.js';
import { computeContentHash } from '../types.js';

const TEST_DIR = path.join(process.cwd(), '.test-memory-hooks');

describe('MemoryHookService', () => {
  let service: MemoryHookService;

  beforeEach(() => {
    // Clean up test directory
    if (existsSync(TEST_DIR)) {
      rmSync(TEST_DIR, { recursive: true });
    }
    mkdirSync(TEST_DIR, { recursive: true });

    service = new MemoryHookService(TEST_DIR);
  });

  afterEach(async () => {
    // Shutdown service
    try {
      await service.shutdown();
    } catch {
      // Ignore shutdown errors
    }

    // Clean up test directory
    if (existsSync(TEST_DIR)) {
      rmSync(TEST_DIR, { recursive: true });
    }
  });

  describe('initialization', () => {
    it('should initialize successfully', async () => {
      await service.initialize();

      // Database file is created after persist() call
      // Initialize just creates the in-memory database
      // Let's verify by adding some data and persisting
      await service.initSession('test', 'test-project');

      const dbPath = path.join(TEST_DIR, '.claude/memory', 'memory.db');
      expect(existsSync(dbPath)).toBe(true);
    });

    it('should be idempotent', async () => {
      await service.initialize();
      await service.initialize(); // Should not throw
    });

    it('should create memory directory if not exists', async () => {
      const memDir = path.join(TEST_DIR, '.claude/memory');
      expect(existsSync(memDir)).toBe(false);

      await service.initialize();

      expect(existsSync(memDir)).toBe(true);
    });
  });

  describe('session management', () => {
    it('should initialize a new session', async () => {
      const session = await service.initSession('session-1', 'test-project', 'Hello Claude');

      expect(session.sessionId).toBe('session-1');
      expect(session.project).toBe('test-project');
      expect(session.prompt).toBe('Hello Claude');
      expect(session.status).toBe('active');
      expect(session.observationCount).toBe(0);
    });

    it('should return existing session on re-init', async () => {
      const session1 = await service.initSession('session-1', 'test-project', 'First prompt');
      const session2 = await service.initSession('session-1', 'test-project', 'Second prompt');

      expect(session1.sessionId).toBe(session2.sessionId);
      expect(session1.prompt).toBe('First prompt'); // Original prompt preserved
    });

    it('should get session by ID', async () => {
      await service.initSession('session-1', 'test-project', 'Test prompt');

      const session = service.getSession('session-1');

      expect(session).not.toBeNull();
      expect(session?.sessionId).toBe('session-1');
      expect(session?.project).toBe('test-project');
    });

    it('should return null for non-existent session', async () => {
      await service.initialize();

      const session = service.getSession('non-existent');

      expect(session).toBeNull();
    });

    it('should complete a session with summary', async () => {
      await service.initSession('session-1', 'test-project');
      await service.completeSession('session-1', 'Task completed successfully');

      const session = service.getSession('session-1');

      expect(session?.status).toBe('completed');
      expect(session?.summary).toBe('Task completed successfully');
      expect(session?.endedAt).toBeGreaterThan(0);
    });

    it('should get recent sessions', async () => {
      await service.initSession('session-1', 'test-project', 'First');
      // Small delay to ensure different timestamps
      await new Promise(resolve => setTimeout(resolve, 10));
      await service.initSession('session-2', 'test-project', 'Second');
      await service.initSession('session-3', 'other-project', 'Third');

      const sessions = await service.getRecentSessions('test-project', 10);

      expect(sessions.length).toBe(2);
      expect(sessions[0].sessionId).toBe('session-2'); // Most recent first
      expect(sessions[1].sessionId).toBe('session-1');
    });

    it('should limit recent sessions', async () => {
      await service.initSession('session-1', 'test-project');
      await service.initSession('session-2', 'test-project');
      await service.initSession('session-3', 'test-project');

      const sessions = await service.getRecentSessions('test-project', 2);

      expect(sessions.length).toBe(2);
    });
  });

  describe('observation management', () => {
    it('should store an observation', async () => {
      await service.initSession('session-1', 'test-project');

      const observation = await service.storeObservation(
        'session-1',
        'test-project',
        'Read',
        { file_path: '/path/to/file.ts' },
        { content: 'file contents' },
        TEST_DIR
      );

      expect(observation.id).toMatch(/^obs_/);
      expect(observation.sessionId).toBe('session-1');
      expect(observation.project).toBe('test-project');
      expect(observation.toolName).toBe('Read');
      expect(observation.type).toBe('read');
      expect(observation.title).toBe('Read /path/to/file.ts');
    });

    it('should increment session observation count', async () => {
      await service.initSession('session-1', 'test-project');

      await service.storeObservation('session-1', 'test-project', 'Read', {}, {}, TEST_DIR);
      await service.storeObservation('session-1', 'test-project', 'Write', {}, {}, TEST_DIR);

      const session = service.getSession('session-1');

      expect(session?.observationCount).toBe(2);
    });

    it('should get session observations', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'a.ts' }, {}, TEST_DIR);
      // Small delay to ensure different timestamps
      await new Promise(resolve => setTimeout(resolve, 10));
      await service.storeObservation('session-1', 'test-project', 'Write', { file_path: 'b.ts' }, {}, TEST_DIR);

      const observations = await service.getSessionObservations('session-1');

      expect(observations.length).toBe(2);
      // Most recent first
      expect(observations[0].toolName).toBe('Write');
      expect(observations[1].toolName).toBe('Read');
    });

    it('should get recent observations for project', async () => {
      await service.initSession('session-1', 'test-project');
      await service.initSession('session-2', 'test-project');

      await service.storeObservation('session-1', 'test-project', 'Read', {}, {}, TEST_DIR);
      await service.storeObservation('session-2', 'test-project', 'Write', {}, {}, TEST_DIR);

      const observations = await service.getRecentObservations('test-project', 10);

      expect(observations.length).toBe(2);
    });

    it('should truncate large responses', async () => {
      await service.initSession('session-1', 'test-project');

      const largeResponse = { content: 'A'.repeat(10000) };
      const observation = await service.storeObservation(
        'session-1',
        'test-project',
        'Read',
        {},
        largeResponse,
        TEST_DIR
      );

      expect(observation.toolResponse.length).toBeLessThan(10000);
      expect(observation.toolResponse).toContain('[truncated]');
    });

    it('should handle null/undefined tool input and response', async () => {
      await service.initSession('session-1', 'test-project');

      // Pass null values - should use empty object fallback
      const observation = await service.storeObservation(
        'session-1',
        'test-project',
        'Read',
        null,
        undefined,
        TEST_DIR
      );

      expect(observation.toolInput).toBe('{}');
      expect(observation.toolResponse).toBe('{}');
    });
  });

  describe('context generation', () => {
    it('should get context for project', async () => {
      await service.initSession('session-1', 'test-project', 'First task');
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'file.ts' }, {}, TEST_DIR);
      await service.completeSession('session-1', 'Completed first task');

      const context = await service.getContext('test-project');

      expect(context.recentObservations.length).toBe(1);
      expect(context.previousSessions.length).toBe(1);
      expect(context.markdown).toContain('# Memory Context');
      expect(context.markdown).toContain('test-project');
    });

    it('should include tool-usage instructions in context header', async () => {
      await service.initSession('session-1', 'test-project', 'Test');
      await service.storeObservation('session-1', 'test-project', 'Read', {}, {}, TEST_DIR);

      const context = await service.getContext('test-project');

      expect(context.markdown).toContain('Memory tools available');
      expect(context.markdown).toContain('memory_search');
      expect(context.markdown).toContain('memory_timeline');
      expect(context.markdown).toContain('memory_details');
      expect(context.markdown).toContain('memory_save');
      expect(context.markdown).toContain('memory_recall');
      expect(context.markdown).toContain('memory_delete');
      expect(context.markdown).toContain('memory_update');
    });

    it('should include observation IDs in context', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'file.ts' }, {}, TEST_DIR);

      const context = await service.getContext('test-project');
      const obs = context.recentObservations[0];

      // Observation ID should appear in markdown (format: [obs_xxxx_yyyy])
      expect(context.markdown).toContain(`[${obs.id}]`);
    });

    it('should include token economics footer when context exists', async () => {
      await service.initSession('session-1', 'test-project', 'Test');
      await service.storeObservation('session-1', 'test-project', 'Read', {}, {}, TEST_DIR);
      await service.completeSession('session-1', 'Done');

      const context = await service.getContext('test-project');

      expect(context.markdown).toContain('tokens shown');
      expect(context.markdown).toContain('tokens available');
      expect(context.markdown).toContain('memory_search');
      expect(context.markdown).toContain('memory_details');
    });

    it('should include all observation type icons in context', async () => {
      await service.initSession('session-1', 'test-project');

      // Store observations of different types to test icon coverage
      await service.storeObservation('session-1', 'test-project', 'Read', {}, {}, TEST_DIR);   // read icon
      await service.storeObservation('session-1', 'test-project', 'Write', {}, {}, TEST_DIR);  // write icon
      await service.storeObservation('session-1', 'test-project', 'Bash', {}, {}, TEST_DIR);   // execute icon
      await service.storeObservation('session-1', 'test-project', 'WebSearch', {}, {}, TEST_DIR); // search icon
      await service.storeObservation('session-1', 'test-project', 'Unknown', {}, {}, TEST_DIR);   // default icon

      const context = await service.getContext('test-project');

      // Verify icons are in the markdown
      expect(context.markdown).toContain('📖'); // read
      expect(context.markdown).toContain('✏️'); // write
      expect(context.markdown).toContain('⚡'); // execute
      expect(context.markdown).toContain('🔍'); // search
      expect(context.markdown).toContain('•');  // default/other
    });

    it('should return empty context for new project', async () => {
      await service.initialize();

      const context = await service.getContext('new-project');

      expect(context.recentObservations.length).toBe(0);
      expect(context.previousSessions.length).toBe(0);
      expect(context.markdown).toContain('No previous session context');
    });

    it('should format relative times correctly in context', async () => {
      const baseTime = Date.now();

      // Create session with observations at different times
      await service.initSession('session-time', 'test-project');

      // Store an observation
      await service.storeObservation('session-time', 'test-project', 'Read', {}, {}, TEST_DIR);

      // Mock Date.now to simulate time passing
      const originalDateNow = Date.now;

      // Test "just now" (less than 1 minute)
      vi.spyOn(Date, 'now').mockReturnValue(baseTime + 30000); // 30 seconds later
      let context = await service.getContext('test-project');
      expect(context.markdown).toContain('just now');

      // Test "Xm ago" (minutes)
      vi.spyOn(Date, 'now').mockReturnValue(baseTime + 5 * 60000); // 5 minutes later
      context = await service.getContext('test-project');
      expect(context.markdown).toMatch(/\dm ago/);

      // Test "Xh ago" (hours)
      vi.spyOn(Date, 'now').mockReturnValue(baseTime + 3 * 3600000); // 3 hours later
      context = await service.getContext('test-project');
      expect(context.markdown).toMatch(/\dh ago/);

      // Test "Xd ago" (days)
      vi.spyOn(Date, 'now').mockReturnValue(baseTime + 3 * 86400000); // 3 days later
      context = await service.getContext('test-project');
      expect(context.markdown).toMatch(/\dd ago/);

      // Test date format (more than 7 days)
      vi.spyOn(Date, 'now').mockReturnValue(baseTime + 10 * 86400000); // 10 days later
      context = await service.getContext('test-project');
      // Should contain a date format like "1/20/2026" or similar
      expect(context.markdown).toMatch(/\d{1,2}\/\d{1,2}\/\d{4}/);

      // Restore
      vi.restoreAllMocks();
    });

    it('should format context as markdown', async () => {
      await service.initSession('session-1', 'test-project', 'Test prompt');
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'file.ts' }, {}, TEST_DIR);
      await service.completeSession('session-1', 'Done');

      const context = await service.getContext('test-project');

      expect(context.markdown).toContain('## Recent Activity');
      expect(context.markdown).toContain('## Previous Sessions');
      expect(context.markdown).toContain('Read');
    });

    it('should truncate long prompts in session context', async () => {
      const longPrompt = 'A'.repeat(150); // More than 100 characters
      await service.initSession('session-1', 'test-project', longPrompt);
      await service.completeSession('session-1', 'Done');

      const context = await service.getContext('test-project');

      // Should contain truncated prompt with ellipsis
      expect(context.markdown).toContain('A'.repeat(100));
      expect(context.markdown).toContain('...');
    });

    it('should show active session status', async () => {
      // Create an active session (not completed)
      await service.initSession('session-active', 'test-project', 'Active task');

      const context = await service.getContext('test-project');

      // Active sessions should show → instead of ✓
      expect(context.markdown).toContain('→');
    });

    it('should handle observations without title', async () => {
      await service.initSession('session-1', 'test-project');

      // Store an observation - the service will generate a title
      await service.storeObservation('session-1', 'test-project', 'CustomTool', {}, {}, TEST_DIR);

      const context = await service.getContext('test-project');

      // Should not error and should include the tool name
      expect(context.markdown).toContain('CustomTool');
    });
  });

  describe('summary generation', () => {
    it('should generate summary from observations', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'a.ts' }, {}, TEST_DIR);
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'b.ts' }, {}, TEST_DIR);
      await service.storeObservation('session-1', 'test-project', 'Write', { file_path: 'c.ts' }, {}, TEST_DIR);
      await service.storeObservation('session-1', 'test-project', 'Bash', { command: 'npm test' }, {}, TEST_DIR);

      const summary = await service.generateSummary('session-1');

      expect(summary).toContain('file(s) modified');
      expect(summary).toContain('file(s) read');
      expect(summary).toContain('command(s) executed');
    });

    it('should return default summary for empty session', async () => {
      await service.initSession('session-1', 'test-project');

      const summary = await service.generateSummary('session-1');

      expect(summary).toContain('No activity recorded');
    });

    it('should list files in summary', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation('session-1', 'test-project', 'Write', { file_path: 'src/index.ts' }, {}, TEST_DIR);
      await service.storeObservation('session-1', 'test-project', 'Write', { file_path: 'src/utils.ts' }, {}, TEST_DIR);

      const summary = await service.generateSummary('session-1');

      expect(summary).toContain('src/index.ts');
      expect(summary).toContain('src/utils.ts');
    });

    it('should include search count in summary', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation('session-1', 'test-project', 'WebSearch', { query: 'test' }, {}, TEST_DIR);
      await service.storeObservation('session-1', 'test-project', 'WebFetch', { url: 'http://test.com' }, {}, TEST_DIR);

      const summary = await service.generateSummary('session-1');

      expect(summary).toContain('search(es)');
    });

    it('should show file count when more than 5 files touched', async () => {
      await service.initSession('session-1', 'test-project');

      // Touch more than 5 files
      for (let i = 0; i < 7; i++) {
        await service.storeObservation('session-1', 'test-project', 'Write', { file_path: `file${i}.ts` }, {}, TEST_DIR);
      }

      const summary = await service.generateSummary('session-1');

      expect(summary).toContain('7 file(s) modified');
    });
  });

  describe('enrichObservation', () => {
    const originalEnv = process.env.AGENTKITS_AI_ENRICHMENT;

    beforeEach(() => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      resetAIEnrichmentCache();
    });

    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
      resetAIEnrichmentCache();
      if (originalEnv === undefined) {
        delete process.env.AGENTKITS_AI_ENRICHMENT;
      } else {
        process.env.AGENTKITS_AI_ENRICHMENT = originalEnv;
      }
    });

    it('should enrich an existing observation with AI data', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read',
        { file_path: 'auth.ts' }, { content: 'export class Auth {}' }, TEST_DIR
      );

      // Reset cache and set up mock AI enrichment
      resetAIEnrichmentCache();
      const validResponse = JSON.stringify({
        subtitle: 'Examining auth module',
        narrative: 'Read the auth module to understand login flow.',
        facts: ['File has 200 lines', 'Uses JWT tokens'],
        concepts: ['authentication', 'jwt'],
      });
      _setRunClaudePrintMockForTesting(() => validResponse);

      const result = await service.enrichObservation(obs.id);
      expect(result).toBe(true);

      // Verify the observation was updated in DB
      const observations = await service.getSessionObservations('session-1');
      expect(observations[0].subtitle).toBe('Examining auth module');
      expect(observations[0].narrative).toBe('Read the auth module to understand login flow.');
      expect(observations[0].facts).toContain('File has 200 lines');
      expect(observations[0].concepts).toContain('jwt');
    });

    it('should return false for non-existent observation', async () => {
      await service.initialize();
      const result = await service.enrichObservation('obs_nonexistent_0000');
      expect(result).toBe(false);
    });

    it('should return false when AI enrichment returns null', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', {}, {}, TEST_DIR
      );

      // Mock CLI that returns invalid response
      _setRunClaudePrintMockForTesting(() => 'not valid json');

      const result = await service.enrichObservation(obs.id);
      expect(result).toBe(false);

      // Original template data should still be intact
      const observations = await service.getSessionObservations('session-1');
      expect(observations[0].subtitle).toBeDefined();
      expect(observations[0].subtitle.length).toBeGreaterThan(0);
    });

    it('should return false when AI enrichment throws', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', {}, {}, TEST_DIR
      );

      // Mock CLI that throws
      _setRunClaudePrintMockForTesting(() => { throw new Error('CLI error'); });

      const result = await service.enrichObservation(obs.id);
      expect(result).toBe(false);
    });

    it('should preserve template data when enrichment is disabled', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read',
        { file_path: 'src/index.ts' }, { content: 'hello' }, TEST_DIR
      );

      // Template data should be present immediately
      expect(obs.subtitle).toBeDefined();
      expect(obs.subtitle.length).toBeGreaterThan(0);
      expect(obs.narrative).toBeDefined();
      expect(obs.narrative.length).toBeGreaterThan(0);
    });
  });

  describe('persistence', () => {
    it('should auto-recreate database if deleted', async () => {
      // Create and populate first instance
      await service.initSession('session-1', 'test-project', 'Test prompt');
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'file.ts' }, {}, TEST_DIR);
      await service.shutdown();

      // Delete the database file
      const dbPath = path.join(TEST_DIR, '.claude/memory', 'memory.db');
      expect(existsSync(dbPath)).toBe(true);
      rmSync(dbPath);
      expect(existsSync(dbPath)).toBe(false);

      // Create new instance - should auto-create new database
      const service2 = new MemoryHookService(TEST_DIR);
      await service2.initialize();

      // Old data should be gone
      const session = service2.getSession('session-1');
      expect(session).toBeNull();

      // But we can create new data
      await service2.initSession('session-2', 'test-project', 'New prompt');
      const newSession = service2.getSession('session-2');
      expect(newSession).not.toBeNull();
      expect(newSession?.prompt).toBe('New prompt');

      // Database file should exist again
      await service2.shutdown();
      expect(existsSync(dbPath)).toBe(true);
    });

    it('should persist data across service restarts', async () => {
      // Create and populate first instance
      await service.initSession('session-1', 'test-project', 'Test prompt');
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'file.ts' }, {}, TEST_DIR);
      await service.shutdown();

      // Create second instance
      const service2 = new MemoryHookService(TEST_DIR);
      await service2.initialize();

      const session = service2.getSession('session-1');
      const observations = await service2.getSessionObservations('session-1');

      expect(session).not.toBeNull();
      expect(session?.prompt).toBe('Test prompt');
      expect(observations.length).toBe(1);

      await service2.shutdown();
    });
  });

  describe('content hash deduplication', () => {
    it('should deduplicate identical prompts within 5-minute window', async () => {
      await service.initSession('session-1', 'test-project');

      const prompt1 = await service.saveUserPrompt('session-1', 'test-project', 'Hello Claude');
      const prompt2 = await service.saveUserPrompt('session-1', 'test-project', 'Hello Claude');

      // Should return the same prompt (dedup)
      expect(prompt1.id).toBe(prompt2.id);
      expect(prompt1.contentHash).toBeDefined();
      expect(prompt2.contentHash).toBe(prompt1.contentHash);
    });

    it('should allow different prompts in same session', async () => {
      await service.initSession('session-1', 'test-project');

      const prompt1 = await service.saveUserPrompt('session-1', 'test-project', 'First prompt');
      const prompt2 = await service.saveUserPrompt('session-1', 'test-project', 'Second prompt');

      expect(prompt1.id).not.toBe(prompt2.id);
      expect(prompt1.promptNumber).toBe(1);
      expect(prompt2.promptNumber).toBe(2);
    });

    it('should deduplicate identical observations within 60-second window', async () => {
      await service.initSession('session-1', 'test-project');

      const obs1 = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );
      const obs2 = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );

      // Should return the same observation (dedup)
      expect(obs1.id).toBe(obs2.id);

      // Session count should only increment once
      const session = service.getSession('session-1');
      expect(session?.observationCount).toBe(1);
    });

    it('should allow same tool on different files', async () => {
      await service.initSession('session-1', 'test-project');

      const obs1 = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'a.ts' }, {}, TEST_DIR
      );
      const obs2 = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'b.ts' }, {}, TEST_DIR
      );

      expect(obs1.id).not.toBe(obs2.id);
    });
  });

  describe('session resume detection', () => {
    it('should link new session to recent parent in same project', async () => {
      // Create first session
      await service.initSession('session-old', 'test-project');

      // Create second session shortly after
      const session2 = await service.initSession('session-new', 'test-project');

      expect(session2.parentSessionId).toBe('session-old');
    });

    it('should not link sessions from different projects', async () => {
      await service.initSession('session-1', 'project-a');
      const session2 = await service.initSession('session-2', 'project-b');

      expect(session2.parentSessionId).toBeUndefined();
    });

    it('should return existing session on re-init (no duplicate parent)', async () => {
      await service.initSession('session-1', 'test-project');
      const first = await service.initSession('session-2', 'test-project');
      const second = await service.initSession('session-2', 'test-project');

      // Re-init returns the same session
      expect(first.sessionId).toBe(second.sessionId);
      expect(first.parentSessionId).toBe(second.parentSessionId);
    });
  });

  describe('context XML wrapper', () => {
    it('should wrap context in agentkits-memory-context tags', async () => {
      await service.initSession('session-1', 'test-project', 'Test');
      await service.storeObservation('session-1', 'test-project', 'Read', {}, {}, TEST_DIR);

      const context = await service.getContext('test-project');

      expect(context.markdown).toContain('<agentkits-memory-context>');
      expect(context.markdown).toContain('</agentkits-memory-context>');
      expect(context.markdown).toContain("Use these naturally when relevant. Don't force them into every response.");
    });
  });

  describe('context grouping by prompt', () => {
    it('should group observations by prompt number when prompts exist', async () => {
      await service.initSession('session-1', 'test-project');

      // Save prompt first
      await service.saveUserPrompt('session-1', 'test-project', 'Fix the bug');

      // Store observation linked to prompt 1
      await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'bug.ts' }, {}, TEST_DIR
      );

      const context = await service.getContext('test-project');

      // Should have prompt-based grouping
      expect(context.markdown).toContain('Prompt #1');
      expect(context.markdown).toContain('Fix the bug');
    });
  });

  describe('compressObservation', () => {
    const originalEnv = process.env.AGENTKITS_AI_ENRICHMENT;

    beforeEach(() => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      resetAIEnrichmentCache();
    });

    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
      resetAIEnrichmentCache();
      if (originalEnv === undefined) {
        delete process.env.AGENTKITS_AI_ENRICHMENT;
      } else {
        process.env.AGENTKITS_AI_ENRICHMENT = originalEnv;
      }
    });

    it('should compress an observation and clear raw data', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read',
        { file_path: 'auth.ts' }, { content: 'big file content' }, TEST_DIR
      );

      _setRunClaudePrintMockForTesting(() =>
        JSON.stringify({ compressed_summary: 'Read auth.ts for login flow analysis' })
      );

      const result = await service.compressObservation(obs.id);
      expect(result).toBe(true);

      // Verify compressed data in DB
      const observations = await service.getSessionObservations('session-1');
      expect(observations[0].compressedSummary).toBe('Read auth.ts for login flow analysis');
      expect(observations[0].isCompressed).toBe(true);
      expect(observations[0].toolInput).toBe('{}'); // raw data cleared
      expect(observations[0].toolResponse).toBe('{}'); // raw data cleared
    });

    it('should skip already-compressed observations', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', {}, {}, TEST_DIR
      );

      _setRunClaudePrintMockForTesting(() =>
        JSON.stringify({ compressed_summary: 'First compression' })
      );

      // First compress
      await service.compressObservation(obs.id);

      // Second compress should skip (already compressed)
      const result = await service.compressObservation(obs.id);
      expect(result).toBe(false);
    });

    it('should return false for non-existent observation', async () => {
      await service.initialize();
      const result = await service.compressObservation('obs_nonexistent_0000');
      expect(result).toBe(false);
    });

    it('should return false when AI returns null', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', {}, {}, TEST_DIR
      );

      _setRunClaudePrintMockForTesting(() => 'not json');

      const result = await service.compressObservation(obs.id);
      expect(result).toBe(false);
    });
  });

  describe('compressSessionObservations', () => {
    const originalEnv = process.env.AGENTKITS_AI_ENRICHMENT;

    beforeEach(() => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      resetAIEnrichmentCache();
    });

    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
      resetAIEnrichmentCache();
      if (originalEnv === undefined) {
        delete process.env.AGENTKITS_AI_ENRICHMENT;
      } else {
        process.env.AGENTKITS_AI_ENRICHMENT = originalEnv;
      }
    });

    it('should compress all session observations and create digest', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation('session-1', 'test-project', 'Read', { file_path: 'a.ts' }, {}, TEST_DIR);
      await service.storeObservation('session-1', 'test-project', 'Write', { file_path: 'b.ts' }, {}, TEST_DIR);

      // Save structured summary (needed for digest generation)
      const structured = await service.generateStructuredSummary('session-1');
      await service.saveSessionSummary(structured);

      let callCount = 0;
      _setRunClaudePrintMockForTesting(() => {
        callCount++;
        // First two calls: observation compression, third: session digest
        if (callCount <= 2) {
          return JSON.stringify({ compressed_summary: `Compressed obs ${callCount}` });
        }
        return JSON.stringify({ digest: 'Session compressed all observations successfully.' });
      });

      const result = await service.compressSessionObservations('session-1');
      expect(result.compressed).toBe(2);
      expect(result.digestCreated).toBe(true);
    });

    it('should handle session with no summary gracefully', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation('session-1', 'test-project', 'Read', {}, {}, TEST_DIR);

      _setRunClaudePrintMockForTesting(() =>
        JSON.stringify({ compressed_summary: 'Compressed' })
      );

      const result = await service.compressSessionObservations('session-1');
      expect(result.compressed).toBe(1);
      expect(result.digestCreated).toBe(false); // No summary = no digest
    });
  });

  describe('processCompressionQueue', () => {
    const originalEnv = process.env.AGENTKITS_AI_ENRICHMENT;

    beforeEach(() => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      resetAIEnrichmentCache();
    });

    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
      resetAIEnrichmentCache();
      if (originalEnv === undefined) {
        delete process.env.AGENTKITS_AI_ENRICHMENT;
      } else {
        process.env.AGENTKITS_AI_ENRICHMENT = originalEnv;
      }
    });

    it('should process compress tasks from queue', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );

      // Queue a compress task manually
      service.queueTask('compress', 'observations', obs.id);

      _setRunClaudePrintMockForTesting(() =>
        JSON.stringify({ compressed_summary: 'Read test.ts' })
      );

      const count = await service.processCompressionQueue();
      expect(count).toBe(1);

      // Verify observation is compressed
      const observations = await service.getSessionObservations('session-1');
      expect(observations[0].compressedSummary).toBe('Read test.ts');
      expect(observations[0].isCompressed).toBe(true);
    });

    it('should return 0 when queue is empty', async () => {
      await service.initialize();
      const count = await service.processCompressionQueue();
      expect(count).toBe(0);
    });
  });

  describe('task queue retry limits', () => {
    const originalEnv = process.env.AGENTKITS_AI_ENRICHMENT;

    beforeEach(() => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      resetAIEnrichmentCache();
    });

    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
      resetAIEnrichmentCache();
      if (originalEnv === undefined) {
        delete process.env.AGENTKITS_AI_ENRICHMENT;
      } else {
        process.env.AGENTKITS_AI_ENRICHMENT = originalEnv;
      }
    });

    it('should skip tasks that have reached max retries', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );

      // Queue a compress task and set retry_count to 3 (max)
      service.queueTask('compress', 'observations', obs.id);
      service.db.prepare("UPDATE task_queue SET retry_count = 3 WHERE task_type = 'compress'").run();

      _setRunClaudePrintMockForTesting(() =>
        JSON.stringify({ compressed_summary: 'Should not run' })
      );

      const count = await service.processCompressionQueue();
      expect(count).toBe(0); // Skipped — retry limit reached

      // Task should still be in queue as pending with retry_count=3
      const task = service.db.prepare("SELECT * FROM task_queue WHERE task_type = 'compress'").get() as Record<string, unknown>;
      expect(task.status).toBe('pending');
      expect(task.retry_count).toBe(3);
    });

    it('should increment retry_count on failure and mark failed at max', async () => {
      await service.initSession('session-1', 'test-project');

      // Queue a compress task for observations table
      service.db.prepare(
        "INSERT INTO task_queue (task_type, target_table, target_id, created_at) VALUES ('compress', 'observations', 'bad-id', ?)"
      ).run(Date.now());

      // Monkey-patch compressObservation to throw (simulating unhandled error)
      const origCompress = service.compressObservation.bind(service);
      service.compressObservation = async () => { throw new Error('unexpected failure'); };

      // Worker loop retries within a single call — all 3 attempts exhaust in one run
      const count = await service.processCompressionQueue();
      expect(count).toBe(3); // 3 failed attempts processed

      // Task should now be marked 'failed' with retry_count=3
      const task = service.db.prepare("SELECT * FROM task_queue WHERE task_type = 'compress'").get() as Record<string, unknown>;
      expect(task.status).toBe('failed');
      expect(task.retry_count).toBe(3);

      // Next call skips entirely — no pending tasks under retry limit
      const count2 = await service.processCompressionQueue();
      expect(count2).toBe(0);

      // Restore
      service.compressObservation = origCompress;
    });

    it('should include retry_count column in task_queue schema', async () => {
      await service.initialize();
      const cols = service.db.prepare("PRAGMA table_info(task_queue)").all() as Array<{ name: string }>;
      expect(cols.some(c => c.name === 'retry_count')).toBe(true);
    });

    it('should default retry_count to 0 for new tasks', async () => {
      await service.initSession('session-1', 'test-project');
      service.queueTask('embed', 'observations', 'test-id');
      const task = service.db.prepare("SELECT retry_count FROM task_queue WHERE task_type = 'embed'").get() as Record<string, unknown>;
      expect(task.retry_count).toBe(0);
    });
  });

  describe('computeContentHash', () => {
    it('should produce consistent hashes', () => {
      const hash1 = computeContentHash('a', 'b', 'c');
      const hash2 = computeContentHash('a', 'b', 'c');
      expect(hash1).toBe(hash2);
    });

    it('should produce different hashes for different inputs', () => {
      const hash1 = computeContentHash('a', 'b');
      const hash2 = computeContentHash('a', 'c');
      expect(hash1).not.toBe(hash2);
    });

    it('should produce 16-char hex string', () => {
      const hash = computeContentHash('test');
      expect(hash).toMatch(/^[0-9a-f]{16}$/);
    });
  });

  // ===== Embedding Reliability =====

  describe('hasPendingEmbeddings', () => {
    it('should return false when no pending tasks or missing embeddings', async () => {
      await service.initialize();
      expect(service.hasPendingEmbeddings()).toBe(false);
    });

    it('should return true when pending embed tasks exist', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );
      // storeObservation auto-queues embed task
      expect(service.hasPendingEmbeddings()).toBe(true);
    });

    it('should return true when observations have null embeddings', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );
      // Clear task queue but leave embedding null
      service.db.prepare("DELETE FROM task_queue").run();
      expect(service.hasPendingEmbeddings()).toBe(true);
    });

    it('should return false when db not initialized', async () => {
      // service.db is null before initialize
      expect(service.hasPendingEmbeddings()).toBe(false);
    });

    it('should ignore failed tasks at max retries', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );
      // Set all tasks to failed with max retries
      service.db.prepare("UPDATE task_queue SET status = 'failed', retry_count = 3").run();
      // But observations still have null embeddings — should detect via DB scan
      expect(service.hasPendingEmbeddings()).toBe(true);
    });
  });

  describe('hasPendingEnrichments', () => {
    it('should return false when no pending enrich tasks', async () => {
      await service.initialize();
      expect(service.hasPendingEnrichments()).toBe(false);
    });

    it('should return true when pending enrich tasks exist', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );
      // Manually queue an enrich task
      service.db.prepare(
        "INSERT INTO task_queue (task_type, target_id, target_table, status, created_at) VALUES ('enrich', ?, 'observations', 'pending', datetime('now'))"
      ).run(obs.id);
      expect(service.hasPendingEnrichments()).toBe(true);
    });

    it('should ignore failed tasks at max retries', async () => {
      await service.initialize();
      service.db.prepare(
        "INSERT INTO task_queue (task_type, target_id, target_table, status, retry_count, created_at) VALUES ('enrich', 'obs-1', 'observations', 'failed', 3, datetime('now'))"
      ).run();
      expect(service.hasPendingEnrichments()).toBe(false);
    });

    it('should return false when db not initialized', () => {
      expect(service.hasPendingEnrichments()).toBe(false);
    });
  });

  describe('hasPendingCompressions', () => {
    it('should return false when no pending compress tasks', async () => {
      await service.initialize();
      expect(service.hasPendingCompressions()).toBe(false);
    });

    it('should return true when pending compress tasks exist', async () => {
      await service.initSession('session-1', 'test-project');
      const obs = await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'test.ts' }, {}, TEST_DIR
      );
      service.db.prepare(
        "INSERT INTO task_queue (task_type, target_id, target_table, status, created_at) VALUES ('compress', ?, 'observations', 'pending', datetime('now'))"
      ).run(obs.id);
      expect(service.hasPendingCompressions()).toBe(true);
    });

    it('should return true when pending digest tasks exist', async () => {
      await service.initSession('session-1', 'test-project');
      service.db.prepare(
        "INSERT INTO task_queue (task_type, target_id, target_table, status, created_at) VALUES ('digest', 'session-1', 'sessions', 'pending', datetime('now'))"
      ).run();
      expect(service.hasPendingCompressions()).toBe(true);
    });

    it('should ignore failed tasks at max retries', async () => {
      await service.initialize();
      service.db.prepare(
        "INSERT INTO task_queue (task_type, target_id, target_table, status, retry_count, created_at) VALUES ('compress', 'obs-1', 'observations', 'failed', 3, datetime('now'))"
      ).run();
      expect(service.hasPendingCompressions()).toBe(false);
    });

    it('should return false when db not initialized', () => {
      expect(service.hasPendingCompressions()).toBe(false);
    });
  });

  // ===== Persistent Settings =====

  describe('loadSettings / saveSettings', () => {
    it('should return defaults when no settings file exists', async () => {
      await service.initialize();
      const settings = service.loadSettings();
      expect(settings.context.showSummaries).toBe(true);
      expect(settings.context.showPrompts).toBe(true);
      expect(settings.context.showObservations).toBe(true);
      expect(settings.context.showToolGuidance).toBe(true);
      expect(settings.context.maxSummaries).toBe(3);
      expect(settings.context.maxPrompts).toBe(10);
      expect(settings.context.maxObservations).toBe(10);
    });

    it('should read settings from .claude/memory/settings.json', async () => {
      await service.initialize();
      // Write a custom settings file
      const settingsPath = path.join(TEST_DIR, '.claude', 'memory', 'settings.json');
      mkdirSync(path.dirname(settingsPath), { recursive: true });
      writeFileSync(settingsPath, JSON.stringify({
        context: { showSummaries: false, maxObservations: 25 },
      }));

      const settings = service.loadSettings();
      expect(settings.context.showSummaries).toBe(false);
      expect(settings.context.maxObservations).toBe(25);
      // Missing keys get defaults
      expect(settings.context.showPrompts).toBe(true);
      expect(settings.context.maxSummaries).toBe(3);
    });

    it('should return defaults on corrupted settings file', async () => {
      await service.initialize();
      const settingsPath = path.join(TEST_DIR, '.claude', 'memory', 'settings.json');
      mkdirSync(path.dirname(settingsPath), { recursive: true });
      writeFileSync(settingsPath, '{ invalid json');

      const settings = service.loadSettings();
      expect(settings.context.showSummaries).toBe(true);
      expect(settings.context.maxObservations).toBe(10);
    });

    it('should save settings to disk', async () => {
      await service.initialize();
      const customSettings = {
        context: {
          showSummaries: false,
          showPrompts: true,
          showObservations: true,
          showToolGuidance: false,
          maxSummaries: 5,
          maxPrompts: 20,
          maxObservations: 30,
        },
      };
      service.saveSettings(customSettings);

      // Verify file contents
      const settingsPath = path.join(TEST_DIR, '.claude', 'memory', 'settings.json');
      const saved = JSON.parse(readFileSync(settingsPath, 'utf-8'));
      expect(saved.context.showSummaries).toBe(false);
      expect(saved.context.maxObservations).toBe(30);
    });

    it('should round-trip save and load', async () => {
      await service.initialize();
      const original = {
        context: {
          showSummaries: false,
          showPrompts: false,
          showObservations: true,
          showToolGuidance: true,
          maxSummaries: 1,
          maxPrompts: 5,
          maxObservations: 15,
        },
      };
      service.saveSettings(original);
      const loaded = service.loadSettings();
      expect(loaded).toEqual(original);
    });

    it('should save and load aiProvider settings', async () => {
      await service.initialize();
      const settings = {
        context: {
          showSummaries: true,
          showPrompts: true,
          showObservations: true,
          showToolGuidance: true,
          maxSummaries: 3,
          maxPrompts: 10,
          maxObservations: 10,
        },
        aiProvider: {
          provider: 'openai' as const,
          apiKey: 'sk-test-key',
          baseUrl: 'https://openrouter.ai/api/v1',
          model: 'anthropic/claude-3.5-haiku',
        },
      };
      service.saveSettings(settings);
      const loaded = service.loadSettings();
      expect(loaded.aiProvider).toBeDefined();
      expect(loaded.aiProvider!.provider).toBe('openai');
      expect(loaded.aiProvider!.apiKey).toBe('sk-test-key');
      expect(loaded.aiProvider!.baseUrl).toBe('https://openrouter.ai/api/v1');
      expect(loaded.aiProvider!.model).toBe('anthropic/claude-3.5-haiku');
    });

    it('should return undefined aiProvider when not set in settings', async () => {
      await service.initialize();
      const loaded = service.loadSettings();
      expect(loaded.aiProvider).toBeUndefined();
    });
  });

  describe('getContext with settings', () => {
    it('should use settings from disk', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'a.ts' }, {}, TEST_DIR
      );

      // Save settings to disable summaries
      service.saveSettings({
        context: {
          showSummaries: false,
          showPrompts: true,
          showObservations: true,
          showToolGuidance: false,
          maxSummaries: 3,
          maxPrompts: 10,
          maxObservations: 10,
        },
      });

      const context = await service.getContext('test-project');
      // Tool guidance should be absent when showToolGuidance=false
      expect(context.markdown).not.toContain('Memory tools available');
    });

    it('should respect configOverride over disk settings', async () => {
      await service.initSession('session-1', 'test-project');
      await service.storeObservation(
        'session-1', 'test-project', 'Read', { file_path: 'a.ts' }, {}, TEST_DIR
      );

      // Disk settings: guidance enabled
      service.saveSettings({
        context: {
          showSummaries: true,
          showPrompts: true,
          showObservations: true,
          showToolGuidance: true,
          maxSummaries: 3,
          maxPrompts: 10,
          maxObservations: 10,
        },
      });

      // Override: disable guidance
      const context = await service.getContext('test-project', {
        showSummaries: true,
        showPrompts: true,
        showObservations: true,
        showToolGuidance: false,
        maxSummaries: 3,
        maxPrompts: 10,
        maxObservations: 10,
      });
      expect(context.markdown).not.toContain('Memory tools available');
    });

    it('should limit observations by maxObservations setting', async () => {
      await service.initSession('session-1', 'test-project');
      // Store 5 observations
      for (let i = 0; i < 5; i++) {
        await service.storeObservation(
          'session-1', 'test-project', 'Read', { file_path: `file${i}.ts` }, {}, TEST_DIR
        );
      }

      // Set maxObservations=2
      service.saveSettings({
        context: {
          showSummaries: true,
          showPrompts: true,
          showObservations: true,
          showToolGuidance: true,
          maxSummaries: 3,
          maxPrompts: 10,
          maxObservations: 2,
        },
      });

      const context = await service.getContext('test-project');
      expect(context.recentObservations.length).toBe(2);
    });
  });

  describe('createHookService factory', () => {
    it('should create service with default config', () => {
      const svc = createHookService(TEST_DIR);

      expect(svc).toBeInstanceOf(MemoryHookService);
    });
  });

  // ===== Feature #5: Intent Tags =====

  describe('intent detection in storeObservation', () => {
    it('should add intent tags to concepts when prompt exists', async () => {
      await service.initialize();
      await service.initSession('intent-session', 'test-project', 'Fix the login bug');
      await service.saveUserPrompt('intent-session', 'test-project', 'Fix the login bug');

      const obs = await service.storeObservation(
        'intent-session', 'test-project', 'Edit',
        { file_path: 'src/auth.ts', old_string: 'foo', new_string: 'bar' },
        { success: true }, TEST_DIR
      );

      expect(obs.concepts).toBeDefined();
      const intentConcepts = obs.concepts!.filter(c => c.startsWith('intent:'));
      expect(intentConcepts.length).toBeGreaterThan(0);
      expect(intentConcepts).toContain('intent:bugfix');
    });

    it('should default to investigation for read without prompt', async () => {
      await service.initialize();
      await service.initSession('intent-session-2', 'test-project');

      const obs = await service.storeObservation(
        'intent-session-2', 'test-project', 'Read',
        { file_path: 'src/app.ts' },
        { content: 'file contents' }, TEST_DIR
      );

      const intentConcepts = obs.concepts!.filter(c => c.startsWith('intent:'));
      expect(intentConcepts).toContain('intent:investigation');
    });
  });

  describe('getLatestPromptText', () => {
    it('should return latest prompt text', async () => {
      await service.initialize();
      await service.initSession('prompt-text-session', 'test-project', 'Hello');
      await service.saveUserPrompt('prompt-text-session', 'test-project', 'First prompt');
      await service.saveUserPrompt('prompt-text-session', 'test-project', 'Second prompt');

      const text = service.getLatestPromptText('prompt-text-session');
      expect(text).toBe('Second prompt');
    });

    it('should return null when no prompts exist', async () => {
      await service.initialize();
      const text = service.getLatestPromptText('nonexistent-session');
      expect(text).toBeNull();
    });
  });

  // ===== Feature #8: Lifecycle Management =====

  describe('lifecycle management', () => {
    it('should archive old completed sessions', async () => {
      await service.initialize();

      // Create an old completed session
      await service.initSession('old-session', 'test-project', 'old task');
      await service.completeSession('old-session', 'Done');

      // Manually backdate the session
      // @ts-expect-error accessing private db for testing
      service.db.prepare("UPDATE sessions SET ended_at = ? WHERE session_id = ?").run(
        Date.now() - 40 * 86400000, // 40 days ago
        'old-session'
      );

      const result = await service.runLifecycleTasks({ archiveAfterDays: 30 });
      expect(result.archived).toBe(1);

      // Verify session is archived
      const session = service.getSession('old-session');
      expect(session?.status).toBe('archived');
    });

    it('should not archive recent sessions', async () => {
      await service.initialize();

      await service.initSession('recent-session', 'test-project', 'recent task');
      await service.completeSession('recent-session', 'Done');

      const result = await service.runLifecycleTasks({ archiveAfterDays: 30 });
      expect(result.archived).toBe(0);

      const session = service.getSession('recent-session');
      expect(session?.status).toBe('completed');
    });

    it('should delete archived sessions when autoDelete enabled', async () => {
      await service.initialize();

      await service.initSession('delete-session', 'test-project', 'delete task');
      await service.completeSession('delete-session', 'Done');

      // @ts-expect-error accessing private db for testing
      service.db.prepare("UPDATE sessions SET status = 'archived', ended_at = ? WHERE session_id = ?").run(
        Date.now() - 100 * 86400000, // 100 days ago
        'delete-session'
      );

      const result = await service.runLifecycleTasks({
        autoDelete: true,
        deleteAfterDays: 90,
      });
      expect(result.deleted).toBe(1);
      expect(result.vacuumed).toBe(true);

      const session = service.getSession('delete-session');
      expect(session).toBeNull();
    });

    it('should not delete when autoDelete is false (default)', async () => {
      await service.initialize();

      await service.initSession('keep-session', 'test-project', 'keep task');
      await service.completeSession('keep-session', 'Done');

      // @ts-expect-error accessing private db for testing
      service.db.prepare("UPDATE sessions SET status = 'archived', ended_at = ? WHERE session_id = ?").run(
        Date.now() - 100 * 86400000,
        'keep-session'
      );

      const result = await service.runLifecycleTasks({ autoDelete: false });
      expect(result.deleted).toBe(0);

      const session = service.getSession('keep-session');
      expect(session).not.toBeNull();
    });

    it('should queue compression for old uncompressed observations', async () => {
      await service.initialize();
      await service.initSession('compress-lc-session', 'test-project', 'task');

      await service.storeObservation(
        'compress-lc-session', 'test-project', 'Read',
        { file_path: 'file.ts' }, { content: 'data' }, TEST_DIR
      );

      // Backdate the observation
      // @ts-expect-error accessing private db for testing
      service.db.prepare("UPDATE observations SET timestamp = ? WHERE session_id = ?").run(
        Date.now() - 10 * 86400000, // 10 days ago
        'compress-lc-session'
      );

      const result = await service.runLifecycleTasks({ compressAfterDays: 7 });
      expect(result.compressed).toBe(1);
    });
  });

  describe('lifecycle stats', () => {
    it('should return database statistics', async () => {
      await service.initialize();

      await service.initSession('stats-session', 'test-project', 'stats');
      await service.storeObservation(
        'stats-session', 'test-project', 'Read',
        { file_path: 'file.ts' }, { content: 'data' }, TEST_DIR
      );
      await service.saveUserPrompt('stats-session', 'test-project', 'test prompt');

      const stats = await service.getLifecycleStats();
      expect(stats.totalSessions).toBeGreaterThanOrEqual(1);
      expect(stats.activeSessions).toBeGreaterThanOrEqual(1);
      expect(stats.totalObservations).toBeGreaterThanOrEqual(1);
      expect(stats.totalPrompts).toBeGreaterThanOrEqual(1);
      expect(stats.dbSizeBytes).toBeGreaterThan(0);
    });
  });

  // ===== Feature #9: Export/Import =====

  describe('structured diff capture', () => {
    it('should include diff facts for Edit observations', async () => {
      await service.initialize();
      await service.initSession('diff-session', 'test-project');
      const obs = await service.storeObservation(
        'diff-session', 'test-project', 'Edit',
        { file_path: 'src/auth.ts', old_string: 'function login(user) {', new_string: 'function login(user, opts) {' },
        {}, TEST_DIR
      );

      expect(obs.facts).toBeDefined();
      expect(obs.facts!.some(f => f.includes('DIFF'))).toBe(true);
      expect(obs.facts!.some(f => f.includes('function login(user) {'))).toBe(true);
      expect(obs.facts!.some(f => f.includes('function login(user, opts) {'))).toBe(true);
    });

    it('should include diff info in narrative for Edit', async () => {
      await service.initialize();
      await service.initSession('diff-session-2', 'test-project');
      const obs = await service.storeObservation(
        'diff-session-2', 'test-project', 'Edit',
        { file_path: 'src/app.ts', old_string: 'const x = 1;', new_string: 'const x = 2;' },
        {}, TEST_DIR
      );

      expect(obs.narrative).toBeDefined();
      expect(obs.narrative).toContain('const x = 1;');
      expect(obs.narrative).toContain('const x = 2;');
    });

    it('should handle MultiEdit with multiple diffs', async () => {
      await service.initialize();
      await service.initSession('multi-diff', 'test-project');
      const obs = await service.storeObservation(
        'multi-diff', 'test-project', 'MultiEdit',
        {
          file_path: 'src/index.ts',
          edits: [
            { old_string: 'import { a } from "./a"', new_string: 'import { a, b } from "./a"' },
            { old_string: 'export default a;', new_string: 'export default { a, b };' },
          ],
        },
        {}, TEST_DIR
      );

      expect(obs.facts!.filter(f => f.includes('DIFF')).length).toBe(2);
    });
  });

  describe('decision rationale in summaries', () => {
    it('should extract decisions from Edit observations', async () => {
      await service.initialize();
      await service.initSession('decision-session', 'test-project');
      await service.saveUserPrompt('decision-session', 'test-project', 'Fix the auth bug');

      await service.storeObservation(
        'decision-session', 'test-project', 'Edit',
        { file_path: 'src/auth.ts', old_string: 'function login(user) {', new_string: 'function login(user, opts) {' },
        {}, TEST_DIR
      );

      const summary = await service.generateStructuredSummary('decision-session');

      expect(summary.decisions).toBeDefined();
      expect(summary.decisions.length).toBeGreaterThan(0);
      expect(summary.decisions[0]).toContain('auth.ts');
      expect(summary.decisions[0]).toContain('function login');
    });

    it('should include intent tags in decisions', async () => {
      await service.initialize();
      await service.initSession('intent-decision', 'test-project');
      await service.saveUserPrompt('intent-decision', 'test-project', 'Refactor the handler');

      await service.storeObservation(
        'intent-decision', 'test-project', 'Edit',
        { file_path: 'src/handler.ts', old_string: 'async handle(req)', new_string: 'async handleRequest(req, res)' },
        {}, TEST_DIR
      );

      const summary = await service.generateStructuredSummary('intent-decision');

      expect(summary.decisions.length).toBeGreaterThan(0);
      expect(summary.decisions[0]).toContain('refactor');
    });

    it('should include decisions in saved session summaries', async () => {
      await service.initialize();
      await service.initSession('saved-decision', 'test-project');
      await service.saveUserPrompt('saved-decision', 'test-project', 'Add feature');

      await service.storeObservation(
        'saved-decision', 'test-project', 'Edit',
        { file_path: 'src/feature.ts', old_string: 'const x = 1;', new_string: 'const x = getValue();' },
        {}, TEST_DIR
      );

      const structured = await service.generateStructuredSummary('saved-decision');
      const saved = await service.saveSessionSummary(structured);

      expect(saved.decisions).toBeDefined();
      expect(saved.decisions.length).toBeGreaterThan(0);

      // Verify it roundtrips through DB
      const summaries = await service.getRecentSummaries('test-project');
      const found = summaries.find(s => s.sessionId === 'saved-decision');
      expect(found).toBeDefined();
      expect(found!.decisions.length).toBeGreaterThan(0);
    });

    it('should return empty decisions when no Edit observations', async () => {
      await service.initialize();
      await service.initSession('no-decision', 'test-project');
      await service.storeObservation(
        'no-decision', 'test-project', 'Read',
        { file_path: 'src/app.ts' }, {}, TEST_DIR
      );

      const summary = await service.generateStructuredSummary('no-decision');

      expect(summary.decisions).toEqual([]);
    });

    it('should show decisions in context markdown', async () => {
      await service.initialize();
      await service.initSession('ctx-decision', 'test-project');
      await service.saveUserPrompt('ctx-decision', 'test-project', 'Fix bug');

      await service.storeObservation(
        'ctx-decision', 'test-project', 'Edit',
        { file_path: 'src/fix.ts', old_string: 'return null;', new_string: 'return defaultValue;' },
        {}, TEST_DIR
      );

      const structured = await service.generateStructuredSummary('ctx-decision');
      await service.saveSessionSummary(structured);
      await service.completeSession('ctx-decision', 'Done');

      const ctx = await service.getContext('test-project');
      expect(ctx.markdown).toContain('Decisions');
    });
  });

  describe('errors in structured summaries', () => {
    it('should extract errors from Bash stderr/stdout', async () => {
      await service.initialize();
      await service.initSession('error-session', 'test-project');

      await service.storeObservation(
        'error-session', 'test-project', 'Bash',
        { command: 'npm run build' },
        { stderr: 'Error: TS2304 Cannot find name "foo"', stdout: '' },
        TEST_DIR
      );

      const summary = await service.generateStructuredSummary('error-session');
      expect(summary.errors).toBeDefined();
      expect(summary.errors.length).toBeGreaterThan(0);
      expect(summary.errors[0]).toContain('TS2304');
    });

    it('should not include false positive errors like "0 errors"', async () => {
      await service.initialize();
      await service.initSession('no-error-session', 'test-project');

      await service.storeObservation(
        'no-error-session', 'test-project', 'Bash',
        { command: 'tsc' },
        { stdout: 'Build completed with 0 errors', stderr: '' },
        TEST_DIR
      );

      const summary = await service.generateStructuredSummary('no-error-session');
      expect(summary.errors.length).toBe(0);
    });

    it('should return empty errors when no Bash observations', async () => {
      await service.initialize();
      await service.initSession('read-only-session', 'test-project');

      await service.storeObservation(
        'read-only-session', 'test-project', 'Read',
        { file_path: 'file.ts' }, {}, TEST_DIR
      );

      const summary = await service.generateStructuredSummary('read-only-session');
      expect(summary.errors).toEqual([]);
    });

    it('should cap errors at 10', async () => {
      await service.initialize();
      await service.initSession('many-error-session', 'test-project');

      // Create output with many error lines
      const errorLines = Array.from({ length: 20 }, (_, i) => `Error: issue ${i}`).join('\n');
      await service.storeObservation(
        'many-error-session', 'test-project', 'Bash',
        { command: 'build' },
        { stdout: errorLines, stderr: '' },
        TEST_DIR
      );

      const summary = await service.generateStructuredSummary('many-error-session');
      expect(summary.errors.length).toBeLessThanOrEqual(10);
    });

    it('should include errors in saved session summary', async () => {
      await service.initialize();
      await service.initSession('saved-error', 'test-project');

      await service.storeObservation(
        'saved-error', 'test-project', 'Bash',
        { command: 'tsc' },
        { stderr: 'fatal error: out of memory' },
        TEST_DIR
      );

      const structured = await service.generateStructuredSummary('saved-error');
      const saved = await service.saveSessionSummary(structured);
      expect(saved.errors.length).toBeGreaterThan(0);

      // Verify roundtrip through DB
      const summaries = await service.getRecentSummaries('test-project');
      const found = summaries.find(s => s.sessionId === 'saved-error');
      expect(found).toBeDefined();
      expect(found!.errors.length).toBeGreaterThan(0);
    });

    it('should show errors in context markdown', async () => {
      await service.initialize();
      await service.initSession('ctx-error', 'test-project');

      await service.storeObservation(
        'ctx-error', 'test-project', 'Bash',
        { command: 'npm test' },
        { stderr: 'Error: Test failed unexpectedly' },
        TEST_DIR
      );

      const structured = await service.generateStructuredSummary('ctx-error');
      await service.saveSessionSummary(structured);
      await service.completeSession('ctx-error', 'Done');

      const ctx = await service.getContext('test-project');
      expect(ctx.markdown).toContain('Errors');
    });
  });

  describe('cross-session pattern detection', () => {
    it('should detect recurring concepts across observations', async () => {
      await service.initialize();

      // Create multiple sessions with overlapping concepts
      await service.initSession('pattern-s1', 'test-project');
      await service.storeObservation(
        'pattern-s1', 'test-project', 'Edit',
        { file_path: 'src/auth.ts', old_string: 'function login(user) {', new_string: 'function login(user, opts) {' },
        {}, TEST_DIR
      );

      await service.initSession('pattern-s2', 'test-project');
      await service.storeObservation(
        'pattern-s2', 'test-project', 'Edit',
        { file_path: 'src/auth.ts', old_string: 'function logout() {', new_string: 'function logout(session) {' },
        {}, TEST_DIR
      );

      const patterns = await service.detectCrossSessionPatterns('test-project');

      // Both edits touched 'authentication' concept from auth.ts path
      expect(patterns.length).toBeGreaterThan(0);
      // At least some patterns should appear with count >= 2
      expect(patterns.every(p => p.count >= 2)).toBe(true);
      expect(patterns.every(p => p.category)).toBe(true);
    });

    it('should categorize patterns by prefix', async () => {
      await service.initialize();

      // Create observations with fn: and intent: concepts
      await service.initSession('cat-s1', 'test-project');
      await service.saveUserPrompt('cat-s1', 'test-project', 'Fix the login bug');
      await service.storeObservation(
        'cat-s1', 'test-project', 'Edit',
        { file_path: 'src/app.ts', old_string: 'function handleAuth() {', new_string: 'function handleAuth(opts) {' },
        {}, TEST_DIR
      );

      await service.initSession('cat-s2', 'test-project');
      await service.saveUserPrompt('cat-s2', 'test-project', 'Fix the signup bug');
      await service.storeObservation(
        'cat-s2', 'test-project', 'Edit',
        { file_path: 'src/signup.ts', old_string: 'function handleAuth() {', new_string: 'function handleAuth(token) {' },
        {}, TEST_DIR
      );

      const patterns = await service.detectCrossSessionPatterns('test-project');

      // Check category values
      const categories = new Set(patterns.map(p => p.category));
      // Should have valid categories
      for (const cat of categories) {
        expect(['topic', 'intent', 'function', 'class', 'code-pattern']).toContain(cat);
      }
    });

    it('should return empty for project with no observations', async () => {
      await service.initialize();
      const patterns = await service.detectCrossSessionPatterns('empty-project');
      expect(patterns).toEqual([]);
    });

    it('should respect limit parameter', async () => {
      await service.initialize();
      await service.initSession('limit-s1', 'test-project');

      // Create many observations to generate many concepts
      for (let i = 0; i < 5; i++) {
        await service.storeObservation(
          'limit-s1', 'test-project', 'Edit',
          { file_path: `src/file${i}.ts`, old_string: 'const a = 1;', new_string: 'const a = 2;' },
          {}, TEST_DIR
        );
      }

      const patterns = await service.detectCrossSessionPatterns('test-project', 3);
      expect(patterns.length).toBeLessThanOrEqual(3);
    });
  });

  describe('export/import', () => {
    it('should export sessions with observations and prompts', async () => {
      await service.initialize();
      await service.initSession('export-session', 'test-project', 'export task');
      await service.saveUserPrompt('export-session', 'test-project', 'export prompt');
      await service.storeObservation(
        'export-session', 'test-project', 'Read',
        { file_path: 'file.ts' }, { content: 'data' }, TEST_DIR
      );
      await service.completeSession('export-session', 'Done');

      const data = await service.exportToJSON('test-project');
      expect(data.version).toBe('1.0');
      expect(data.project).toBe('test-project');
      expect(data.sessions.length).toBeGreaterThanOrEqual(1);

      const session = data.sessions.find(s => s.sessionId === 'export-session');
      expect(session).toBeDefined();
      expect(session!.observations.length).toBeGreaterThanOrEqual(1);
      expect(session!.prompts.length).toBeGreaterThanOrEqual(1);
    });

    it('should export specific sessions by ID', async () => {
      await service.initialize();
      await service.initSession('export-a', 'test-project', 'task A');
      await service.initSession('export-b', 'test-project', 'task B');

      const data = await service.exportToJSON('test-project', ['export-a']);
      expect(data.sessions.length).toBe(1);
      expect(data.sessions[0].sessionId).toBe('export-a');
    });

    it('should import exported data with new session IDs', async () => {
      await service.initialize();
      await service.initSession('import-src', 'test-project', 'import task');
      await service.saveUserPrompt('import-src', 'test-project', 'import prompt');
      await service.storeObservation(
        'import-src', 'test-project', 'Read',
        { file_path: 'file.ts' }, { content: 'data' }, TEST_DIR
      );

      const exported = await service.exportToJSON('test-project', ['import-src']);

      // Importing into same DB: content_hash dedup will skip existing obs/prompts
      // but session is always created new
      const result = await service.importFromJSON(exported);

      expect(result.imported.sessions).toBe(1);
      // Observations and prompts are deduplicated by content_hash since they already exist
      expect(result.imported.observations + result.skipped.observations).toBeGreaterThanOrEqual(1);
      expect(result.imported.prompts + result.skipped.prompts).toBeGreaterThanOrEqual(1);
    });

    it('should dedup observations by content_hash on reimport', async () => {
      await service.initialize();
      await service.initSession('dedup-session', 'test-project', 'dedup task');
      await service.storeObservation(
        'dedup-session', 'test-project', 'Read',
        { file_path: 'file.ts' }, { content: 'data' }, TEST_DIR
      );

      const exported = await service.exportToJSON('test-project', ['dedup-session']);

      // First import: content_hash already exists in same DB → skipped
      const result1 = await service.importFromJSON(exported);
      // Second import: still skipped (same hash)
      const result2 = await service.importFromJSON(exported);

      // Both imports should have the session created but obs deduplicated
      expect(result1.imported.sessions).toBe(1);
      expect(result2.imported.sessions).toBe(1);
      // Both skip observations since content_hash already in DB
      expect(result1.skipped.observations + result2.skipped.observations).toBeGreaterThanOrEqual(1);
    });

    it('should preserve errors in export/import roundtrip', async () => {
      await service.initialize();
      await service.initSession('err-export', 'test-project');

      await service.storeObservation(
        'err-export', 'test-project', 'Bash',
        { command: 'build' },
        { stderr: 'Error: compilation failed' },
        TEST_DIR
      );

      const structured = await service.generateStructuredSummary('err-export');
      await service.saveSessionSummary(structured);
      await service.completeSession('err-export', 'Done');

      const exported = await service.exportToJSON('test-project', ['err-export']);
      const session = exported.sessions.find(s => s.sessionId === 'err-export');
      expect(session).toBeDefined();
      expect(session!.summary).toBeDefined();
      expect(session!.summary!.errors.length).toBeGreaterThan(0);
    });
  });
});