@cleocode/core 2026.4.5 → 2026.4.7

package/src/store/__tests__/migration-safety.test.js

@@ -1,756 +0,0 @@
-/**
- * Migration Safety Integration Tests
- *
- * Comprehensive tests covering all failure modes and safety mechanisms:
- * - Corrupted JSON handling
- * - Migration interruption and recovery
- * - Concurrent access blocking
- * - Singleton reset
- * - Backup restore on failure
- * - Atomic rename verification
- * - Idempotency
- * - Data integrity
- * - State file creation
- * - Log file creation
- * - Confirmation requirements
- *
- * @task T4729
- * @epic T4454
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-describe('Migration Safety Integration Tests', () => {
-    let tempDir;
-    let cleoDir;
-    let logsDir;
-    let safetyDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'cleo-safety-'));
-        cleoDir = join(tempDir, '.cleo');
-        logsDir = join(cleoDir, 'logs');
-        safetyDir = join(cleoDir, 'backups', 'safety');
-        await mkdir(cleoDir, { recursive: true });
-        await mkdir(logsDir, { recursive: true });
-        await mkdir(safetyDir, { recursive: true });
-        process.env['CLEO_DIR'] = cleoDir;
-        // Reset SQLite singleton
-        const { closeDb } = await import('../sqlite.js');
-        closeDb();
-        // Clear any existing migration state
-        const { clearMigrationState } = await import('../../migration/state.js');
-        await clearMigrationState(cleoDir);
-    });
-    afterEach(async () => {
-        delete process.env['CLEO_DIR'];
-        // Close DB and cleanup
-        const { closeDb } = await import('../sqlite.js');
-        closeDb();
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    // === Test Data Fixtures ===
-    const createFullTask = (id, overrides = {}) => ({
-        id,
-        title: `Task ${id}`,
-        description: 'Detailed description',
-        status: 'active',
-        priority: 'critical',
-        type: 'epic',
-        phase: 'planning',
-        size: 'large',
-        position: 5,
-        labels: ['test', 'v2'],
-        notes: ['Note 1', 'Note 2'],
-        acceptance: ['Criteria 1'],
-        files: ['src/main.ts'],
-        origin: 'feature-request',
-        blockedBy: 'external',
-        epicLifecycle: 'active',
-        noAutoComplete: true,
-        createdAt: '2026-01-01T00:00:00.000Z',
-        updatedAt: '2026-01-05T00:00:00.000Z',
-        provenance: {
-            createdBy: 'agent-1',
-            modifiedBy: 'agent-2',
-            sessionId: 'sess-001',
-        },
-        ...overrides,
-    });
-    const createTestSession = (id, overrides = {}) => ({
-        id,
-        name: `Session ${id}`,
-        status: 'ended',
-        scope: { type: 'epic', epicId: 'T001' },
-        taskWork: { taskId: 'T002', setAt: '2026-01-01T10:00:00.000Z' },
-        agent: 'claude',
-        notes: ['Session note'],
-        tasksCompleted: ['T003'],
-        tasksCreated: ['T002'],
-        startedAt: '2026-01-01T00:00:00.000Z',
-        endedAt: '2026-01-01T12:00:00.000Z',
-        ...overrides,
-    });
-    const createTodoJson = (tasks = []) => ({
-        version: '2.10.0',
-        project: { name: 'test-project', phases: {} },
-        lastUpdated: new Date().toISOString(),
-        _meta: {
-            schemaVersion: '2.10.0',
-            checksum: '0000000000000000',
-            configVersion: '1.0.0',
-        },
-        focus: { currentTask: null },
-        tasks,
-    });
-    const createSessionsJson = (sessions = []) => ({
-        version: '1.0.0',
-        sessions,
-        _meta: { schemaVersion: '1.0.0', lastUpdated: new Date().toISOString() },
-    });
-    const createArchiveJson = (archivedTasks = []) => ({
-        _meta: { schemaVersion: '2.10.0' },
-        archivedTasks,
-    });
-    // === Failure Scenarios ===
-    describe('Failure Scenarios', () => {
-        it('should fail before destructive ops when JSON is corrupted', async () => {
-            // Setup: Create corrupted todo.json
-            await writeFile(join(cleoDir, 'todo.json'), '{ invalid json }');
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            // Run migration
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const result = await migrateJsonToSqlite();
-            // Assert: Migration failed with parse error
-            expect(result.success).toBe(false);
-            expect(result.errors.length).toBeGreaterThan(0);
-            expect(result.errors[0]).toContain('parse');
-            // Assert: Database was not created (or is empty)
-            const dbPath = join(cleoDir, 'tasks.db');
-            if (existsSync(dbPath)) {
-                // If DB exists, it should be empty/invalid
-                const { getDb } = await import('../sqlite.js');
-                const { count } = await import('drizzle-orm');
-                const { tasks } = await import('../tasks-schema.js');
-                const db = await getDb();
-                const taskCount = db.select({ count: count() }).from(tasks).get();
-                expect(taskCount?.count ?? 0).toBe(0);
-            }
-        });
-        it('should restore from backup when migration fails mid-process', async () => {
-            // Setup: Create initial DB with data
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const { getDb, closeDb } = await import('../sqlite.js');
-            const { tasks } = await import('../tasks-schema.js');
-            const { eq } = await import('drizzle-orm');
-            // First migration: create initial DB
-            const initialTasks = [createFullTask('T001'), createFullTask('T002')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(initialTasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const firstResult = await migrateJsonToSqlite();
-            expect(firstResult.success).toBe(true);
-            expect(firstResult.tasksImported).toBe(2);
-            // Verify DB exists
-            const dbPath = join(cleoDir, 'tasks.db');
-            expect(existsSync(dbPath)).toBe(true);
-            // Create backup manually (simulating pre-migration backup)
-            const backupPath = join(safetyDir, 'tasks.db.pre-migration.test');
-            await writeFile(backupPath, readFileSync(dbPath));
-            // Get original DB content for comparison
-            const originalDbContent = readFileSync(dbPath);
-            // Create corrupted JSON that will cause migration to fail
-            await writeFile(join(cleoDir, 'todo.json'), '{ corrupted }');
-            // Attempt migration (will fail)
-            const secondResult = await migrateJsonToSqlite(undefined, { force: true });
-            // Restore from backup manually (migration doesn't auto-restore on JSON parse error)
-            // In production, this would be handled by the upgrade.ts restore logic
-            await writeFile(dbPath, originalDbContent);
-            closeDb();
-            // Verify DB was restored (re-open to verify)
-            const db = await getDb();
-            const allTasks = await db.select().from(tasks).where(eq(tasks.status, 'active')).all();
-            expect(allTasks.length).toBe(2);
-        });
-        it('should block concurrent migration attempts', async () => {
-            // Setup: Create valid JSON files
-            const tasks = [createFullTask('T001')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            // Acquire lock on DB path
-            const { acquireLock } = await import('../lock.js');
-            const dbPath = join(cleoDir, 'tasks.db');
-            const release = await acquireLock(dbPath, { stale: 5000, retries: 0 });
-            try {
-                // Attempt to acquire lock again (should fail)
-                let lockError = null;
-                try {
-                    await acquireLock(dbPath, { stale: 5000, retries: 0 });
-                }
-                catch (err) {
-                    lockError = err;
-                }
-                // Should fail with lock error
-                expect(lockError).not.toBeNull();
-                expect(lockError.message).toContain('lock');
-            }
-            finally {
-                await release();
-            }
-        });
-        it('should handle migration interruption and resume', async () => {
-            // Setup: Create migration state file simulating interrupted migration
-            const { createMigrationState, updateMigrationPhase, loadMigrationState, completeMigration } = await import('../../migration/state.js');
-            const tasks = [createFullTask('T001'), createFullTask('T002')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            // Create migration state at 'import' phase (interrupted)
-            await createMigrationState(cleoDir);
-            await updateMigrationPhase(cleoDir, 'import');
-            // Check that migration state shows it can be resumed
-            const { canResumeMigration } = await import('../../migration/state.js');
-            const resumeState = await canResumeMigration(cleoDir);
-            expect(resumeState).not.toBeNull();
-            expect(resumeState?.canResume).toBe(true);
-            expect(resumeState?.phase).toBe('import');
-            // Run migration again (should complete successfully)
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const result = await migrateJsonToSqlite();
-            expect(result.success).toBe(true);
-            expect(result.tasksImported).toBe(2);
-            // Mark migration as complete
-            await completeMigration(cleoDir);
-            // Verify state was marked complete
-            const finalState = await loadMigrationState(cleoDir);
-            if (finalState) {
-                expect(finalState.phase).toBe('complete');
-            }
-        });
-        it('should detect and reject zero-task JSON with existing database', async () => {
-            // Setup: Create initial DB with data
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const initialTasks = [createFullTask('T001')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(initialTasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            await migrateJsonToSqlite();
-            const { closeDb } = await import('../sqlite.js');
-            closeDb();
-            // Replace with empty JSON (simulating data loss scenario)
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([])));
-            // Attempt migration without force (should detect mismatch)
-            const result = await migrateJsonToSqlite();
-            // Should warn about data mismatch
-            expect(result.warnings.length).toBeGreaterThan(0);
-            expect(result.warnings[0]).toContain('mismatch');
-        });
-        it('should clear singleton state after migration', async () => {
-            // Setup: Create JSON files
-            const tasks = [createFullTask('T001')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            // Open DB before migration (to create singleton state)
-            const { getDb, closeDb, resetDbState } = await import('../sqlite.js');
-            const dbBefore = await getDb();
-            expect(dbBefore).toBeDefined();
-            closeDb();
-            resetDbState();
-            // Run migration
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            await migrateJsonToSqlite();
-            // After migration, getDb should return fresh instance
-            const dbAfter = await getDb();
-            expect(dbAfter).toBeDefined();
-        });
-        it('should verify backup with checksums not just file size', async () => {
-            // Setup: Create initial DB
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const tasks = [createFullTask('T001')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            await migrateJsonToSqlite();
-            const { closeDb } = await import('../sqlite.js');
-            closeDb();
-            const dbPath = join(cleoDir, 'tasks.db');
-            expect(existsSync(dbPath)).toBe(true);
-            // Create backup with checksum verification
-            const { computeChecksum, compareChecksums } = await import('../../migration/checksum.js');
-            const originalChecksum = await computeChecksum(dbPath);
-            const backupPath = join(safetyDir, 'tasks.db.pre-migration.checksum');
-            await writeFile(backupPath, readFileSync(dbPath));
-            // Verify backup checksum matches original
-            const checksumsMatch = await compareChecksums(dbPath, backupPath);
-            expect(checksumsMatch).toBe(true);
-            // Verify both checksums are valid SHA-256 (64 hex chars)
-            const backupChecksum = await computeChecksum(backupPath);
-            expect(originalChecksum).toHaveLength(64);
-            expect(backupChecksum).toHaveLength(64);
-            expect(originalChecksum).toBe(backupChecksum);
-        });
-    });
-    // === Atomic Operations ===
-    describe('Atomic Operations', () => {
-        it('should never leave database in inconsistent state', async () => {
-            // Setup: Create valid JSON files
-            const tasks = [createFullTask('T001'), createFullTask('T002'), createFullTask('T003')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const result = await migrateJsonToSqlite();
-            // Migration should succeed
-            expect(result.success).toBe(true);
-            // Verify all tasks were imported correctly
-            const { getDb } = await import('../sqlite.js');
-            const { tasks: taskSchema } = await import('../tasks-schema.js');
-            const { count } = await import('drizzle-orm');
-            const db = await getDb();
-            const taskCount = await db.select({ count: count() }).from(taskSchema).get();
-            expect(taskCount?.count).toBe(3);
-            // Verify database is valid (can run queries)
-            const allTasks = await db.select().from(taskSchema).all();
-            expect(allTasks.length).toBe(3);
-            expect(allTasks.every((t) => t.id && t.title)).toBe(true);
-        });
-        it('should use atomic rename, never delete-then-create', async () => {
-            // This test verifies the atomic pattern is used in migration-sqlite.ts
-            // by checking that the code uses temp file + rename pattern
-            const { migrateJsonToSqliteAtomic } = await import('../migration-sqlite.js');
-            // Setup: Create valid JSON files
-            const tasks = [createFullTask('T001')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            // Use atomic migration with temp path
-            const tempDbPath = join(cleoDir, 'tasks.db.migrating');
-            const result = await migrateJsonToSqliteAtomic(tempDir, tempDbPath);
-            if (!result.success) {
-                console.error('ATOMIC MIGRATION ERRORS:', JSON.stringify(result.errors, null, 2));
-            }
-            expect(result.success).toBe(true);
-            // Verify temp file was created
-            expect(existsSync(tempDbPath)).toBe(true);
-            // The migration should have exported to temp file (ready for rename)
-            const tempStats = await stat(tempDbPath);
-            expect(tempStats.size).toBeGreaterThan(0);
-        });
-    });
-    // === Idempotency ===
-    describe('Idempotency', () => {
-        it('should skip migration when data already present', async () => {
-            // Setup: Create and run initial migration
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const tasks = [createFullTask('T001'), createFullTask('T002')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const firstResult = await migrateJsonToSqlite();
-            expect(firstResult.success).toBe(true);
-            expect(firstResult.tasksImported).toBe(2);
-            const { closeDb } = await import('../sqlite.js');
-            closeDb();
-            // Second migration without force should skip
-            const secondResult = await migrateJsonToSqlite();
-            expect(secondResult.success).toBe(true);
-            expect(secondResult.warnings.length).toBeGreaterThan(0);
-            expect(secondResult.warnings[0]).toContain('already contains migrated data');
-            expect(secondResult.tasksImported).toBe(0);
-        });
-        it('should re-import with --force flag', async () => {
-            // Setup: Create and run initial migration
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const tasks = [createFullTask('T001')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            await migrateJsonToSqlite();
-            const { closeDb } = await import('../sqlite.js');
-            closeDb();
-            // Modify JSON with additional task
-            const newTasks = [createFullTask('T001'), createFullTask('T002')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(newTasks)));
-            // Re-import with force
-            const forceResult = await migrateJsonToSqlite(undefined, { force: true });
-            expect(forceResult.success).toBe(true);
-            expect(forceResult.warnings[0]).toContain('Force mode');
-            // Verify both tasks are present
-            const { getDb } = await import('../sqlite.js');
-            const { tasks: taskSchema } = await import('../tasks-schema.js');
-            const { count } = await import('drizzle-orm');
-            const db = await getDb();
-            const taskCount = await db.select({ count: count() }).from(taskSchema).get();
-            expect(taskCount?.count).toBe(2);
-        });
-    });
-    // === Data Integrity ===
-    describe('Data Integrity', () => {
-        it('should preserve all task fields through migration', async () => {
-            const fullTask = createFullTask('T001');
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([fullTask])));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            await migrateJsonToSqlite();
-            const { getTask } = await import('../task-store.js');
-            const task = await getTask('T001');
-            expect(task).not.toBeNull();
-            expect(task.id).toBe('T001');
-            expect(task.title).toBe('Task T001');
-            expect(task.description).toBe('Detailed description');
-            expect(task.status).toBe('active');
-            expect(task.priority).toBe('critical');
-            expect(task.type).toBe('epic');
-            expect(task.phase).toBe('planning');
-            expect(task.size).toBe('large');
-            expect(task.position).toBe(5);
-            expect(task.labels).toEqual(['test', 'v2']);
-            expect(task.notes).toEqual(['Note 1', 'Note 2']);
-            expect(task.acceptance).toEqual(['Criteria 1']);
-            expect(task.files).toEqual(['src/main.ts']);
-            expect(task.origin).toBe('feature-request');
-            expect(task.blockedBy).toBe('external');
-            expect(task.epicLifecycle).toBe('active');
-            expect(task.noAutoComplete).toBe(true);
-            expect(task.createdAt).toBe('2026-01-01T00:00:00.000Z');
-            expect(task.updatedAt).toBe('2026-01-05T00:00:00.000Z');
-            expect(task.provenance?.createdBy).toBe('agent-1');
-            expect(task.provenance?.modifiedBy).toBe('agent-2');
-            expect(task.provenance?.sessionId).toBe('sess-001');
-        });
-        it('should preserve dependencies through migration', async () => {
-            const tasks = [
-                createFullTask('T001'),
-                createFullTask('T002', { depends: ['T001'] }),
-                createFullTask('T003', { depends: ['T001', 'T002'] }),
-            ];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            await migrateJsonToSqlite();
-            const { getTask } = await import('../task-store.js');
-            const t1 = await getTask('T001');
-            const t2 = await getTask('T002');
-            const t3 = await getTask('T003');
-            expect(t1).not.toBeNull();
-            expect(t2).not.toBeNull();
-            expect(t3).not.toBeNull();
-            expect(t2.depends).toContain('T001');
-            expect(t3.depends).toContain('T001');
-            expect(t3.depends).toContain('T002');
-        });
-        it('should preserve sessions through migration', async () => {
-            const sessions = [
-                createTestSession('sess-001'),
-                createTestSession('sess-002', { status: 'active' }),
-            ];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson()));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson(sessions)));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const result = await migrateJsonToSqlite();
-            expect(result.success).toBe(true);
-            expect(result.sessionsImported).toBe(2);
-            const { getSession } = await import('../session-store.js');
-            const s1 = await getSession('sess-001');
-            expect(s1).not.toBeNull();
-            expect(s1.name).toBe('Session sess-001');
-            expect(s1.status).toBe('ended');
-            expect(s1.agent).toBe('claude');
-            const s2 = await getSession('sess-002');
-            expect(s2).not.toBeNull();
-            expect(s2.status).toBe('active');
-        });
-    });
-    // === Safety Mechanisms ===
-    describe('Safety Mechanisms', () => {
-        it('should create state file during migration', async () => {
-            const { createMigrationState, loadMigrationState } = await import('../../migration/state.js');
-            // Create migration state
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([createFullTask('T001')])));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const state = await createMigrationState(cleoDir);
-            expect(state).toBeDefined();
-            expect(state.phase).toBe('init');
-            expect(state.version).toBe('1.0.0');
-            expect(state.startedAt).toBeDefined();
-            // Verify state file was created on disk
-            const loadedState = await loadMigrationState(cleoDir);
-            expect(loadedState).not.toBeNull();
-            expect(loadedState.phase).toBe('init');
-            expect(loadedState.sourceFiles.todoJson).toBeDefined();
-            expect(loadedState.sourceFiles.todoJson.checksum).toBeDefined();
-        });
-        it('should create log file during migration', async () => {
-            const { MigrationLogger } = await import('../../migration/logger.js');
-            const logger = new MigrationLogger(cleoDir);
-            // Log some operations
-            logger.info('init', 'start', 'Migration started');
-            logger.info('backup', 'create', 'Backup created');
-            logger.warn('import', 'skip', 'Skipping duplicate task');
-            const logPath = logger.getLogPath();
-            // Verify log file exists
-            expect(existsSync(logPath)).toBe(true);
-            // Read and verify log entries
-            const logContent = readFileSync(logPath, 'utf-8');
-            const entries = logContent
-                .trim()
-                .split('\n')
-                .map((line) => JSON.parse(line));
-            expect(entries.length).toBeGreaterThanOrEqual(3);
-            expect(entries[0].level).toBe('info');
-            expect(entries[0].phase).toBe('init');
-            expect(entries[0].message).toContain('Migration started');
-            // Verify log file is in logs directory
-            expect(logPath).toContain('logs');
-            expect(logPath).toContain('migration-');
-            expect(logPath).toContain('.jsonl');
-        });
-        it('should track migration progress in state', async () => {
-            const { createMigrationState, updateMigrationProgress, loadMigrationState } = await import('../../migration/state.js');
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([createFullTask('T001'), createFullTask('T002'), createFullTask('T003')])));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const state = await createMigrationState(cleoDir);
-            expect(state.progress.totalTasks).toBe(3);
-            // Update progress
-            await updateMigrationProgress(cleoDir, { tasksImported: 1 });
-            const updatedState = await loadMigrationState(cleoDir);
-            expect(updatedState.progress.tasksImported).toBe(1);
-            expect(updatedState.progress.totalTasks).toBe(3);
-        });
-        it('should track errors and warnings in state', async () => {
-            const { createMigrationState, addMigrationError, addMigrationWarning, loadMigrationState } = await import('../../migration/state.js');
-            await createMigrationState(cleoDir);
-            await addMigrationWarning(cleoDir, 'Test warning');
-            await addMigrationError(cleoDir, 'Test error');
-            const state = await loadMigrationState(cleoDir);
-            expect(state.warnings).toContain('Test warning');
-            expect(state.errors).toContain('Test error');
-            expect(state.phase).toBe('failed');
-        });
-    });
-    // === Checksum Verification ===
-    describe('Checksum Verification', () => {
-        it('should detect modified source files', async () => {
-            const { createMigrationState, verifySourceIntegrity } = await import('../../migration/state.js');
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([createFullTask('T001')])));
-            await createMigrationState(cleoDir);
-            // Verify source files are intact
-            const initialCheck = await verifySourceIntegrity(cleoDir);
-            expect(initialCheck.valid).toBe(true);
-            expect(initialCheck.changed).toHaveLength(0);
-            // Modify the source file
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([createFullTask('T002')])));
-            // Verify source files are now detected as changed
-            const finalCheck = await verifySourceIntegrity(cleoDir);
-            expect(finalCheck.valid).toBe(false);
-            expect(finalCheck.changed.length).toBeGreaterThan(0);
-        });
-        it('should compute consistent checksums for same content', async () => {
-            const { computeChecksum, compareChecksums } = await import('../../migration/checksum.js');
-            const content = JSON.stringify({ test: 'data', array: [1, 2, 3] });
-            const file1 = join(cleoDir, 'test1.json');
-            const file2 = join(cleoDir, 'test2.json');
-            await writeFile(file1, content);
-            await writeFile(file2, content);
-            const checksum1 = await computeChecksum(file1);
-            const checksum2 = await computeChecksum(file2);
-            expect(checksum1).toBe(checksum2);
-            expect(checksum1).toHaveLength(64); // SHA-256 hex length
-            const match = await compareChecksums(file1, file2);
-            expect(match).toBe(true);
-        });
-    });
-    // === Logger Functionality ===
-    describe('Logger Functionality', () => {
-        it('should log file operations with metadata', async () => {
-            const { MigrationLogger } = await import('../../migration/logger.js');
-            const logger = new MigrationLogger(cleoDir);
-            const testFile = join(cleoDir, 'test-file.txt');
-            await writeFile(testFile, 'test content');
-            logger.logFileOperation('test-phase', 'write', testFile, undefined, { custom: 'data' });
-            const summary = logger.getSummary();
-            expect(summary.totalEntries).toBeGreaterThan(0);
-            expect(summary.info).toBeGreaterThan(0);
-            const entries = logger.getEntries();
-            const fileOp = entries.find((e) => e.operation === 'file-write');
-            expect(fileOp).toBeDefined();
-            expect(fileOp.data?.sourcePath).toBeDefined();
-        });
-        it('should log validation results', async () => {
-            const { MigrationLogger } = await import('../../migration/logger.js');
-            const logger = new MigrationLogger(cleoDir);
-            logger.logValidation('validate', 'test-target', true, { field: 'value' });
-            logger.logValidation('validate', 'failing-target', false, { error: 'details' }, ['error1']);
-            const entries = logger.getEntries();
-            expect(entries.some((e) => e.operation === 'validation' && e.data?.valid === true)).toBe(true);
-            expect(entries.some((e) => e.operation === 'validation' && e.data?.valid === false)).toBe(true);
-        });
-        it('should log import progress', async () => {
-            const { MigrationLogger } = await import('../../migration/logger.js');
-            const logger = new MigrationLogger(cleoDir);
-            logger.logImportProgress('import', 'tasks', 50, 100);
-            const entries = logger.getEntriesByPhase('import');
-            const progressEntry = entries.find((e) => e.operation === 'import-progress');
-            expect(progressEntry).toBeDefined();
-            expect(progressEntry.data?.imported).toBe(50);
-            expect(progressEntry.data?.total).toBe(100);
-            expect(progressEntry.data?.percent).toBe(50);
-        });
-    });
-    // === Migration Phases ===
-    describe('Migration Phases', () => {
-        it('should transition through all phases correctly', async () => {
-            const { createMigrationState, updateMigrationPhase, loadMigrationState } = await import('../../migration/state.js');
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([createFullTask('T001')])));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const phases = [
-                'init',
-                'backup',
-                'validate',
-                'import',
-                'verify',
-                'cleanup',
-                'complete',
-            ];
-            await createMigrationState(cleoDir);
-            for (const phase of phases) {
-                await updateMigrationPhase(cleoDir, phase);
-                const state = await loadMigrationState(cleoDir);
-                expect(state.phase).toBe(phase);
-            }
-        });
-        it('should complete migration and cleanup state', async () => {
-            const { createMigrationState, completeMigration, loadMigrationState } = await import('../../migration/state.js');
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([createFullTask('T001')])));
-            await createMigrationState(cleoDir);
-            const completed = await completeMigration(cleoDir);
-            expect(completed.phase).toBe('complete');
-            expect(completed.completedAt).toBeDefined();
-            // State cleanup happens async, so check immediately
-            const state = await loadMigrationState(cleoDir);
-            expect(state).not.toBeNull();
-            expect(state.phase).toBe('complete');
-        });
-        it('should fail migration with error details', async () => {
-            const { createMigrationState, failMigration, loadMigrationState } = await import('../../migration/state.js');
-            await createMigrationState(cleoDir);
-            await failMigration(cleoDir, 'Migration failed: corrupted data');
-            const state = await loadMigrationState(cleoDir);
-            expect(state.phase).toBe('failed');
-            expect(state.errors).toContain('Migration failed: corrupted data');
-        });
-    });
-    // === Dry Run Mode ===
-    describe('Dry Run Mode', () => {
-        it('should preview migration without making changes', async () => {
-            const tasks = [createFullTask('T001')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const result = await migrateJsonToSqlite(undefined, { dryRun: true });
-            expect(result.success).toBe(true);
-            expect(result.warnings.length).toBeGreaterThan(0);
-            expect(result.warnings[0]).toContain('Dry-run');
-            // Database should not be created
-            const dbPath = join(cleoDir, 'tasks.db');
-            // Note: The current implementation may still create DB in dry-run mode
-            // depending on the implementation details
-        });
-        it('should show data counts in dry-run mode', async () => {
-            const tasks = [createFullTask('T001'), createFullTask('T002'), createFullTask('T003')];
-            const sessions = [createTestSession('sess-001')];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson(sessions)));
-            const { countJsonRecords } = await import('../migration-sqlite.js');
-            const counts = countJsonRecords(cleoDir);
-            expect(counts.tasks).toBe(3);
-            expect(counts.sessions).toBe(1);
-        });
-    });
-    // === Archived Tasks ===
-    describe('Archived Task Migration', () => {
-        it('should migrate archived tasks separately', async () => {
-            const activeTasks = [createFullTask('T001')];
-            const archivedTasks = [
-                createFullTask('T100', { status: 'done' }),
-                createFullTask('T101', { status: 'done' }),
-            ];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(activeTasks)));
-            await writeFile(join(cleoDir, 'todo-archive.json'), JSON.stringify(createArchiveJson(archivedTasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const result = await migrateJsonToSqlite();
-            expect(result.success).toBe(true);
-            expect(result.tasksImported).toBe(1);
-            expect(result.archivedImported).toBe(2);
-        });
-        it('should preserve archived task metadata', async () => {
-            const archivedTask = {
-                ...createFullTask('T100', { status: 'done' }),
-                archivedAt: '2026-01-15T00:00:00.000Z',
-                archiveReason: 'completed',
-                cycleTimeDays: 14,
-            };
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson()));
-            await writeFile(join(cleoDir, 'todo-archive.json'), JSON.stringify(createArchiveJson([archivedTask])));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            await migrateJsonToSqlite();
-            const { getDb } = await import('../sqlite.js');
-            const { tasks } = await import('../tasks-schema.js');
-            const { eq } = await import('drizzle-orm');
-            const db = await getDb();
-            const archivedRows = await db.select().from(tasks).where(eq(tasks.status, 'archived')).all();
-            expect(archivedRows.length).toBe(1);
-            expect(archivedRows[0].archivedAt).toBeDefined();
-        });
-    });
-    // === Complex Scenarios ===
-    describe('Complex Scenarios', () => {
-        it('should handle large datasets efficiently', async () => {
-            const manyTasks = Array.from({ length: 100 }, (_, i) => createFullTask(`T${String(i + 1).padStart(3, '0')}`));
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(manyTasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const startTime = Date.now();
-            const result = await migrateJsonToSqlite();
-            const duration = Date.now() - startTime;
-            expect(result.success).toBe(true);
-            expect(result.tasksImported).toBe(100);
-            expect(duration).toBeLessThan(30000); // Should complete within 30 seconds
-        });
-        it('should handle tasks with circular references gracefully', async () => {
-            // Note: This tests that the migration doesn't crash on complex data
-            // Actual circular dependency handling depends on the application logic
-            const tasks = [
-                createFullTask('T001'),
-                createFullTask('T002', { depends: ['T001'] }),
-                createFullTask('T003', { depends: ['T002'] }),
-            ];
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson(tasks)));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const result = await migrateJsonToSqlite();
-            expect(result.success).toBe(true);
-            const { getTask } = await import('../task-store.js');
-            const t2 = await getTask('T002');
-            const t3 = await getTask('T003');
-            expect(t2.depends).toContain('T001');
-            expect(t3.depends).toContain('T002');
-        });
-        it('should handle missing optional fields gracefully', async () => {
-            const minimalTask = {
-                id: 'T001',
-                title: 'Minimal Task',
-                status: 'pending',
-                priority: 'medium',
-                createdAt: '2026-01-01T00:00:00.000Z',
-                // Missing many optional fields
-            };
-            await writeFile(join(cleoDir, 'todo.json'), JSON.stringify(createTodoJson([minimalTask])));
-            await writeFile(join(cleoDir, 'sessions.json'), JSON.stringify(createSessionsJson()));
-            const { migrateJsonToSqlite } = await import('../migration-sqlite.js');
-            const result = await migrateJsonToSqlite();
-            expect(result.success).toBe(true);
-            expect(result.tasksImported).toBe(1);
-            const { getTask } = await import('../task-store.js');
-            const task = await getTask('T001');
-            expect(task).not.toBeNull();
-            expect(task.title).toBe('Minimal Task');
-        });
-    });
-});
-//# sourceMappingURL=migration-safety.test.js.map