@jamesaphoenix/tx-core 0.4.2 → 0.4.4

package/dist/services/sync-service.js

@@ -1,10 +1,11 @@
-import { Context, Effect, Layer, Schema } from "effect";
-import { writeFileSync, renameSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { Context, Effect, Exit, Layer, Schema } from "effect";
+import { writeFile, rename, readFile, stat, mkdir, access } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { dirname, resolve } from "node:path";
 import { DatabaseError, ValidationError } from "../errors.js";
 import { SqliteClient } from "../db.js";
 import { TaskService } from "./task-service.js";
-import { TaskRepository } from "../repo/task-repo.js";
 import { DependencyRepository } from "../repo/dep-repo.js";
 import { SyncOperation as SyncOperationSchema } from "../schemas/sync.js";
 /**
@@ -14,6 +15,92 @@ import { SyncOperation as SyncOperationSchema } from "../schemas/sync.js";
 export class SyncService extends Context.Tag("SyncService")() {
 }
 const DEFAULT_JSONL_PATH = ".tx/tasks.jsonl";
+/**
+ * Empty import result for early returns.
+ */
+const EMPTY_IMPORT_RESULT = {
+    imported: 0,
+    skipped: 0,
+    conflicts: 0,
+    dependencies: { added: 0, removed: 0, skipped: 0, failures: [] }
+};
+/**
+ * Topologically sort task operations so parents are processed before children.
+ * This ensures foreign key constraints are satisfied during import.
+ *
+ * Uses Kahn's algorithm:
+ * 1. Find all tasks with no parent (or parent not in import set) - these have no deps
+ * 2. Process them and mark as "done"
+ * 3. For remaining tasks, if their parent is "done", add them to the queue
+ * 4. Repeat until all tasks are processed
+ *
+ * @param entries Array of [taskId, { op, ts }] entries from taskStates Map
+ * @returns Sorted array with parents before children
+ */
+function topologicalSortTasks(entries) {
+    // Separate upserts from deletes - deletes don't have parent dependencies
+    const upsertEntries = entries.filter(([, { op }]) => op.op === "upsert");
+    const deleteEntries = entries.filter(([, { op }]) => op.op === "delete");
+    // Build set of task IDs being imported
+    const importingIds = new Set(upsertEntries.map(([id]) => id));
+    // Build parent→children adjacency list
+    const children = new Map();
+    for (const [id] of upsertEntries) {
+        children.set(id, []);
+    }
+    for (const [id, { op }] of upsertEntries) {
+        const parentId = op.data?.parentId;
+        if (parentId && importingIds.has(parentId)) {
+            const parentChildren = children.get(parentId);
+            if (parentChildren) {
+                parentChildren.push(id);
+            }
+        }
+    }
+    // Calculate in-degree (number of parents in import set)
+    const inDegree = new Map();
+    for (const [id, { op }] of upsertEntries) {
+        const parentId = op.data?.parentId;
+        // Only count parent as dependency if it's in the import set
+        const hasParentInSet = parentId && importingIds.has(parentId);
+        inDegree.set(id, hasParentInSet ? 1 : 0);
+    }
+    // Queue starts with tasks that have no parent in import set (in-degree 0)
+    const queue = [];
+    for (const [id, degree] of inDegree) {
+        if (degree === 0) {
+            queue.push(id);
+        }
+    }
+    // Build sorted result
+    const sorted = [];
+    const entryMap = new Map(upsertEntries);
+    while (queue.length > 0) {
+        const id = queue.shift();
+        const entry = entryMap.get(id);
+        if (entry) {
+            sorted.push([id, entry]);
+        }
+        // Decrement in-degree of children and add to queue if now 0
+        const childIds = children.get(id) ?? [];
+        for (const childId of childIds) {
+            const currentDegree = inDegree.get(childId) ?? 0;
+            const newDegree = currentDegree - 1;
+            inDegree.set(childId, newDegree);
+            if (newDegree === 0) {
+                queue.push(childId);
+            }
+        }
+    }
+    // If we didn't process all tasks, there's a cycle - fall back to original order
+    // (This shouldn't happen with valid data since parent-child can't be circular)
+    if (sorted.length < upsertEntries.length) {
+        // Return original upsert entries followed by deletes
+        return [...upsertEntries, ...deleteEntries];
+    }
+    // Return sorted upserts followed by deletes
+    return [...sorted, ...deleteEntries];
+}
 /**
  * Convert a Task to a TaskUpsertOp for JSONL export.
  */
@@ -41,21 +128,26 @@ const depToAddOp = (dep) => ({
     blockerId: dep.blockerId,
     blockedId: dep.blockedId
 });
+/**
+ * Check if a file exists without blocking the event loop.
+ */
+const fileExists = (filePath) => Effect.promise(() => access(filePath).then(() => true).catch(() => false));
 /**
  * Write content to file atomically using temp file + rename.
+ * Uses async fs operations to avoid blocking the event loop.
  */
-const atomicWrite = (filePath, content) => {
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    const tempPath = `${filePath}.tmp.${Date.now()}`;
-    writeFileSync(tempPath, content, "utf-8");
-    renameSync(tempPath, filePath);
-};
+const atomicWrite = (filePath, content) => Effect.tryPromise({
+    try: async () => {
+        const dir = dirname(filePath);
+        await mkdir(dir, { recursive: true });
+        const tempPath = `${filePath}.tmp.${Date.now()}.${process.pid}.${Math.random().toString(36).slice(2)}`;
+        await writeFile(tempPath, content, "utf-8");
+        await rename(tempPath, filePath);
+    },
+    catch: (cause) => new DatabaseError({ cause })
+});
 export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* () {
     const taskService = yield* TaskService;
-    const taskRepo = yield* TaskRepository;
     const depRepo = yield* DependencyRepository;
     const db = yield* SqliteClient;
     // Helper: Get config value from sync_config table
@@ -76,9 +168,9 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
     return {
         export: (path) => Effect.gen(function* () {
             const filePath = resolve(path ?? DEFAULT_JSONL_PATH);
-            // Get all tasks and dependencies
+            // Get all tasks and dependencies (explicit high limit for full export)
             const tasks = yield* taskService.list();
-            const deps = yield* depRepo.getAll();
+            const deps = yield* depRepo.getAll(100_000);
             // Convert to sync operations
             const taskOps = tasks.map(taskToUpsertOp);
             const depOps = deps.map(depToAddOp);
@@ -87,10 +179,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             // Convert to JSONL format (one JSON object per line)
             const jsonl = allOps.map(op => JSON.stringify(op)).join("\n");
             // Write atomically
-            yield* Effect.try({
-                try: () => atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : "")),
-                catch: (cause) => new DatabaseError({ cause })
-            });
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
             // Record export time
             yield* setConfig("last_export", new Date().toISOString());
             return {
@@ -100,20 +189,23 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
         }),
         import: (path) => Effect.gen(function* () {
             const filePath = resolve(path ?? DEFAULT_JSONL_PATH);
-            // Check if file exists
-            if (!existsSync(filePath)) {
-                return { imported: 0, skipped: 0, conflicts: 0 };
+            // Check if file exists (outside transaction - no DB access)
+            const importFileExists = yield* fileExists(filePath);
+            if (!importFileExists) {
+                return EMPTY_IMPORT_RESULT;
             }
-            // Read and parse JSONL file
-            const content = yield* Effect.try({
-                try: () => readFileSync(filePath, "utf-8"),
+            // Read and parse JSONL file (outside transaction - no DB access)
+            const content = yield* Effect.tryPromise({
+                try: () => readFile(filePath, "utf-8"),
                 catch: (cause) => new DatabaseError({ cause })
             });
             const lines = content.trim().split("\n").filter(Boolean);
             if (lines.length === 0) {
-                return { imported: 0, skipped: 0, conflicts: 0 };
+                return EMPTY_IMPORT_RESULT;
             }
-            // Parse all operations with Schema validation
+            // Compute hash of file content for concurrent modification detection (TOCTOU protection)
+            const fileHash = createHash("sha256").update(content).digest("hex");
+            // Parse all operations with Schema validation (outside transaction - no DB access)
             const ops = [];
             for (const line of lines) {
                 const parsed = yield* Effect.try({
@@ -144,104 +236,249 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                     }
                 }
             }
-            let imported = 0;
-            let skipped = 0;
-            let conflicts = 0;
-            // Apply task operations
-            for (const [id, { op }] of taskStates) {
-                if (op.op === "upsert") {
-                    const existing = yield* taskRepo.findById(id);
-                    if (!existing) {
-                        // Create new task with the specified ID
-                        const now = new Date();
-                        const task = {
-                            id: id,
-                            title: op.data.title,
-                            description: op.data.description,
-                            status: op.data.status,
-                            parentId: op.data.parentId,
-                            score: op.data.score,
-                            createdAt: new Date(op.ts),
-                            updatedAt: new Date(op.ts),
-                            completedAt: op.data.status === "done" ? now : null,
-                            metadata: op.data.metadata
-                        };
-                        yield* taskRepo.insert(task);
-                        imported++;
-                    }
-                    else {
-                        // Update if JSONL timestamp is newer than existing
-                        const existingTs = existing.updatedAt.toISOString();
-                        if (op.ts > existingTs) {
-                            const updated = {
-                                ...existing,
-                                title: op.data.title,
-                                description: op.data.description,
-                                status: op.data.status,
-                                parentId: op.data.parentId,
-                                score: op.data.score,
-                                updatedAt: new Date(op.ts),
-                                completedAt: op.data.status === "done" ? (existing.completedAt ?? new Date()) : null,
-                                metadata: op.data.metadata
-                            };
-                            yield* taskRepo.update(updated);
-                            imported++;
+            // Apply task operations in topological order (parents before children)
+            // This ensures foreign key constraints are satisfied when importing
+            // tasks where child timestamp < parent timestamp
+            const sortedTaskEntries = topologicalSortTasks([...taskStates.entries()]);
+            // Prepare statements outside transaction to minimize write lock duration.
+            // better-sqlite3 prepared statements are reusable across transactions.
+            const findTaskStmt = db.prepare("SELECT * FROM tasks WHERE id = ?");
+            const insertTaskStmt = db.prepare(`INSERT INTO tasks (id, title, description, status, parent_id, score, created_at, updated_at, completed_at, metadata)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            const updateTaskStmt = db.prepare(`UPDATE tasks SET title = ?, description = ?, status = ?, parent_id = ?,
+             score = ?, updated_at = ?, completed_at = ?, metadata = ? WHERE id = ?`);
+            const deleteTaskStmt = db.prepare("DELETE FROM tasks WHERE id = ?");
+            const insertDepStmt = db.prepare("INSERT INTO task_dependencies (blocker_id, blocked_id, created_at) VALUES (?, ?, ?)");
+            const checkDepExistsStmt = db.prepare("SELECT 1 FROM task_dependencies WHERE blocker_id = ? AND blocked_id = ?");
+            const deleteDepStmt = db.prepare("DELETE FROM task_dependencies WHERE blocker_id = ? AND blocked_id = ?");
+            const setConfigStmt = db.prepare("INSERT OR REPLACE INTO sync_config (key, value, updated_at) VALUES (?, ?, datetime('now'))");
+            const checkParentExistsStmt = db.prepare("SELECT 1 FROM tasks WHERE id = ?");
+            // ALL database operations inside a single transaction for atomicity
+            // If any operation fails, the entire import is rolled back
+            return yield* Effect.acquireUseRelease(
+            // Acquire: Begin transaction
+            Effect.try({
+                try: () => db.exec("BEGIN IMMEDIATE"),
+                catch: (cause) => new DatabaseError({ cause })
+            }), 
+            // Use: Run all database operations
+            () => Effect.try({
+                try: () => {
+                    let imported = 0;
+                    let skipped = 0;
+                    let conflicts = 0;
+                    // Dependency tracking
+                    let depsAdded = 0;
+                    let depsRemoved = 0;
+                    let depsSkipped = 0;
+                    const depFailures = [];
+                    // Apply task operations
+                    for (const [id, { op }] of sortedTaskEntries) {
+                        if (op.op === "upsert") {
+                            const existingRow = findTaskStmt.get(id);
+                            // Validate parentId: if it references a task that doesn't exist
+                            // in the DB, set to null to avoid FK constraint violation.
+                            // Topological sort ensures parents in the import set are already
+                            // inserted by this point, so a missing parent is truly orphaned.
+                            const parentId = op.data.parentId;
+                            const effectiveParentId = parentId && checkParentExistsStmt.get(parentId)
+                                ? parentId
+                                : null;
+                            if (!existingRow) {
+                                // Create new task with the specified ID
+                                const now = new Date();
+                                insertTaskStmt.run(id, op.data.title, op.data.description, op.data.status, effectiveParentId, op.data.score, op.ts, op.ts, op.data.status === "done" ? now.toISOString() : null, JSON.stringify(op.data.metadata));
+                                imported++;
+                            }
+                            else {
+                                // Update if JSONL timestamp is newer than existing
+                                const existingTs = existingRow.updated_at;
+                                if (op.ts > existingTs) {
+                                    updateTaskStmt.run(op.data.title, op.data.description, op.data.status, effectiveParentId, op.data.score, op.ts, op.data.status === "done" ? (existingRow.completed_at ?? new Date().toISOString()) : null, JSON.stringify(op.data.metadata), id);
+                                    imported++;
+                                }
+                                else if (op.ts === existingTs) {
+                                    // Same timestamp - skip
+                                    skipped++;
+                                }
+                                else {
+                                    // Local is newer - conflict
+                                    conflicts++;
+                                }
+                            }
+                        }
+                        else if (op.op === "delete") {
+                            const existingRow = findTaskStmt.get(id);
+                            if (existingRow) {
+                                // Check timestamp - only delete if delete operation is newer
+                                // Per DD-009 Scenario 2: delete wins if its timestamp > local update timestamp
+                                const existingTs = existingRow.updated_at;
+                                if (op.ts > existingTs) {
+                                    deleteTaskStmt.run(id);
+                                    imported++;
+                                }
+                                else if (op.ts === existingTs) {
+                                    // Same timestamp - skip (ambiguous state, but safe to keep local)
+                                    skipped++;
+                                }
+                                else {
+                                    // Local is newer - conflict (local update wins over older delete)
+                                    conflicts++;
+                                }
+                            }
                         }
-                        else if (op.ts === existingTs) {
-                            // Same timestamp - skip
-                            skipped++;
+                    }
+                    // Apply dependency operations with individual error tracking
+                    for (const { op } of depStates.values()) {
+                        if (op.op === "dep_add") {
+                            // Check if dependency already exists
+                            const exists = checkDepExistsStmt.get(op.blockerId, op.blockedId);
+                            if (exists) {
+                                depsSkipped++;
+                                continue;
+                            }
+                            // Try to add dependency, track failures individually
+                            try {
+                                insertDepStmt.run(op.blockerId, op.blockedId, op.ts);
+                                depsAdded++;
+                            }
+                            catch (e) {
+                                // Dependency insert failed (e.g., foreign key constraint, circular dependency)
+                                depFailures.push({
+                                    blockerId: op.blockerId,
+                                    blockedId: op.blockedId,
+                                    error: e instanceof Error ? e.message : String(e)
+                                });
+                            }
                         }
-                        else {
-                            // Local is newer - conflict
-                            conflicts++;
+                        else if (op.op === "dep_remove") {
+                            // Remove dependency - track if it actually existed
+                            const result = deleteDepStmt.run(op.blockerId, op.blockedId);
+                            if (result.changes > 0) {
+                                depsRemoved++;
+                            }
+                            else {
+                                depsSkipped++;
+                            }
                         }
                     }
-                }
-                else if (op.op === "delete") {
-                    const existing = yield* taskRepo.findById(id);
-                    if (existing) {
-                        yield* taskRepo.remove(id);
-                        imported++;
+                    // If any dependency inserts failed, abort the entire transaction.
+                    // This ensures atomicity: tasks and their dependencies are imported
+                    // together or not at all. A partial import (tasks without deps) would
+                    // leave the dependency graph incomplete.
+                    if (depFailures.length > 0) {
+                        const details = depFailures
+                            .map(f => `${f.blockerId} -> ${f.blockedId}: ${f.error}`)
+                            .join("; ");
+                        throw new Error(`Sync import rolled back: ${depFailures.length} dependency failure(s): ${details}`);
                     }
-                }
-            }
-            // Apply dependency operations
-            for (const { op } of depStates.values()) {
-                if (op.op === "dep_add") {
-                    // Add dependency, ignore if already exists
-                    yield* depRepo.insert(op.blockerId, op.blockedId).pipe(Effect.catchAll(() => Effect.void));
-                }
-                else if (op.op === "dep_remove") {
-                    // Remove dependency, ignore if doesn't exist
-                    yield* depRepo.remove(op.blockerId, op.blockedId).pipe(Effect.catchAll(() => Effect.void));
-                }
-            }
-            // Record import time
-            yield* setConfig("last_import", new Date().toISOString());
-            return { imported, skipped, conflicts };
+                    // Verify file hasn't been modified during import (TOCTOU protection).
+                    // Re-read synchronously while holding the DB write lock (BEGIN IMMEDIATE).
+                    // If another process exported between our initial read and now, the hash
+                    // will differ and we roll back to avoid committing stale data.
+                    const verifyContent = readFileSync(filePath, "utf-8");
+                    const verifyHash = createHash("sha256").update(verifyContent).digest("hex");
+                    if (verifyHash !== fileHash) {
+                        throw new Error("Sync import rolled back: JSONL file was modified during import (concurrent export detected). Retry the import.");
+                    }
+                    // Record import time
+                    setConfigStmt.run("last_import", new Date().toISOString());
+                    return {
+                        imported,
+                        skipped,
+                        conflicts,
+                        dependencies: {
+                            added: depsAdded,
+                            removed: depsRemoved,
+                            skipped: depsSkipped,
+                            failures: depFailures
+                        }
+                    };
+                },
+                catch: (cause) => new DatabaseError({ cause })
+            }), 
+            // Release: Commit on success, rollback on failure
+            (_, exit) => Exit.isSuccess(exit)
+                ? Effect.try({
+                    try: () => db.exec("COMMIT"),
+                    catch: (cause) => new DatabaseError({ cause })
+                }).pipe(Effect.orDie)
+                : Effect.try({
+                    try: () => db.exec("ROLLBACK"),
+                    catch: (cause) => new DatabaseError({ cause })
+                }).pipe(Effect.catchAll((rollbackError) => Effect.log(`ROLLBACK failed: ${rollbackError.cause}`))));
         }),
         status: () => Effect.gen(function* () {
             const filePath = resolve(DEFAULT_JSONL_PATH);
-            // Count tasks in database
-            const tasks = yield* taskService.list();
-            const dbTaskCount = tasks.length;
+            // Count tasks in database (SQL COUNT instead of loading all rows)
+            const dbTaskCount = yield* taskService.count();
+            // Count dependencies in database (SQL COUNT instead of loading all rows)
+            const dbDepCount = yield* Effect.try({
+                try: () => {
+                    const row = db.prepare("SELECT COUNT(*) as cnt FROM task_dependencies").get();
+                    return row.cnt;
+                },
+                catch: (cause) => new DatabaseError({ cause })
+            });
             // Count operations in JSONL file and get file info
             let jsonlOpCount = 0;
+            let jsonlTaskCount = 0;
+            let jsonlDepCount = 0;
             let lastExport = null;
-            if (existsSync(filePath)) {
+            const jsonlFileExists = yield* fileExists(filePath);
+            if (jsonlFileExists) {
                 // Get file modification time as lastExport
-                const stats = yield* Effect.try({
-                    try: () => statSync(filePath),
+                const stats = yield* Effect.tryPromise({
+                    try: () => stat(filePath),
                     catch: (cause) => new DatabaseError({ cause })
                 });
                 lastExport = stats.mtime;
                 // Count non-empty lines (each line is one operation)
-                const content = yield* Effect.try({
-                    try: () => readFileSync(filePath, "utf-8"),
+                const content = yield* Effect.tryPromise({
+                    try: () => readFile(filePath, "utf-8"),
                     catch: (cause) => new DatabaseError({ cause })
                 });
                 const lines = content.trim().split("\n").filter(Boolean);
                 jsonlOpCount = lines.length;
+                // Parse JSONL to count EFFECTIVE task and dependency states
+                // After git merges, the file may have multiple operations for the same entity
+                // We need to deduplicate by ID and track the latest operation (timestamp wins)
+                // to get accurate counts that match what the DB state should be after import
+                const taskStates = new Map();
+                const depStates = new Map();
+                for (const line of lines) {
+                    try {
+                        const op = JSON.parse(line);
+                        if (op.op === "upsert" || op.op === "delete") {
+                            const existing = taskStates.get(op.id);
+                            if (!existing || op.ts > existing.ts) {
+                                taskStates.set(op.id, { op: op.op, ts: op.ts });
+                            }
+                        }
+                        else if (op.op === "dep_add" || op.op === "dep_remove") {
+                            const key = `${op.blockerId}:${op.blockedId}`;
+                            const existing = depStates.get(key);
+                            if (!existing || op.ts > existing.ts) {
+                                depStates.set(key, { op: op.op, ts: op.ts });
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines for counting purposes
+                    }
+                }
+                // Count only entities whose latest operation is an "add" operation
+                // (upsert for tasks, dep_add for dependencies)
+                for (const state of taskStates.values()) {
+                    if (state.op === "upsert") {
+                        jsonlTaskCount++;
+                    }
+                }
+                for (const state of depStates.values()) {
+                    if (state.op === "dep_add") {
+                        jsonlDepCount++;
+                    }
+                }
             }
             // Get last export/import timestamps from config
             const lastExportConfig = yield* getConfig("last_export");
@@ -252,13 +489,43 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const autoSyncConfig = yield* getConfig("auto_sync");
             const autoSyncEnabled = autoSyncConfig === "true";
             // Determine if dirty: DB has changes not in JSONL
+            // Per DD-009: dirty if tasks exist AND (no lastExport OR any task/dep updated after lastExport)
+            // Additionally: dirty if counts differ (indicates deletions/removals)
             let isDirty = false;
-            if (dbTaskCount > 0 && !existsSync(filePath)) {
+            if (dbTaskCount > 0 && !jsonlFileExists) {
+                // No JSONL file but tasks exist → dirty
                 isDirty = true;
             }
-            else if (lastExportDate !== null && tasks.length > 0) {
-                // Check if any task was updated after the last export
-                isDirty = tasks.some(task => task.updatedAt > lastExportDate);
+            else if (dbTaskCount > 0 || dbDepCount > 0) {
+                if (lastExportDate === null) {
+                    // Tasks/deps exist but never exported → dirty
+                    isDirty = true;
+                }
+                else {
+                    // Check if any task was updated after the last export (uses idx_tasks_updated index)
+                    const lastExportIso = lastExportDate.toISOString();
+                    const tasksDirty = yield* Effect.try({
+                        try: () => {
+                            const row = db.prepare("SELECT COUNT(*) as cnt FROM tasks WHERE updated_at > ?").get(lastExportIso);
+                            return row.cnt > 0;
+                        },
+                        catch: (cause) => new DatabaseError({ cause })
+                    });
+                    // Check if any dependency was created after the last export
+                    const depsDirty = yield* Effect.try({
+                        try: () => {
+                            const row = db.prepare("SELECT COUNT(*) as cnt FROM task_dependencies WHERE created_at > ?").get(lastExportIso);
+                            return row.cnt > 0;
+                        },
+                        catch: (cause) => new DatabaseError({ cause })
+                    });
+                    // Check if counts differ (indicates deletions occurred since export)
+                    // DB count < JSONL count means tasks/deps were deleted
+                    // DB count > JSONL count means tasks/deps were added (also caught by timestamp check)
+                    const taskCountMismatch = dbTaskCount !== jsonlTaskCount;
+                    const depCountMismatch = dbDepCount !== jsonlDepCount;
+                    isDirty = tasksDirty || depsDirty || taskCountMismatch || depCountMismatch;
+                }
             }
             return {
                 dbTaskCount,
@@ -278,12 +545,13 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
         compact: (path) => Effect.gen(function* () {
             const filePath = resolve(path ?? DEFAULT_JSONL_PATH);
             // Check if file exists
-            if (!existsSync(filePath)) {
+            const compactFileExists = yield* fileExists(filePath);
+            if (!compactFileExists) {
                 return { before: 0, after: 0 };
             }
             // Read and parse JSONL file
-            const content = yield* Effect.try({
-                try: () => readFileSync(filePath, "utf-8"),
+            const content = yield* Effect.tryPromise({
+                try: () => readFile(filePath, "utf-8"),
                 catch: (cause) => new DatabaseError({ cause })
             });
             const lines = content.trim().split("\n").filter(Boolean);
@@ -337,10 +605,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             compacted.sort((a, b) => a.ts.localeCompare(b.ts));
             // Write compacted JSONL atomically
             const newContent = compacted.map(op => JSON.stringify(op)).join("\n");
-            yield* Effect.try({
-                try: () => atomicWrite(filePath, newContent + (newContent.length > 0 ? "\n" : "")),
-                catch: (cause) => new DatabaseError({ cause })
-            });
+            yield* atomicWrite(filePath, newContent + (newContent.length > 0 ? "\n" : ""));
             return { before, after: compacted.length };
         }),
         setLastExport: (timestamp) => setConfig("last_export", timestamp.toISOString()),