@jamesaphoenix/tx-core 0.8.1 → 0.9.0

package/dist/{services/sync-service.js → internal/sync/service-impl.js}

@@ -1,23 +1,31 @@
+// @ts-nocheck
 import { Context, Effect, Exit, Layer, Schema } from "effect";
-import { writeFile, rename, readFile, stat, mkdir, access } from "node:fs/promises";
+import { writeFile, rename, readFile, mkdir, access, appendFile, readdir, rm, stat } from "node:fs/promises";
 import { readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
-import { dirname, resolve, sep } from "node:path";
-import { DatabaseError, ValidationError } from "../errors.js";
-import { SqliteClient } from "../db.js";
-import { TaskService } from "./task-service.js";
-import { DependencyRepository } from "../repo/dep-repo.js";
-import { LearningRepository } from "../repo/learning-repo.js";
-import { FileLearningRepository } from "../repo/file-learning-repo.js";
-import { AttemptRepository } from "../repo/attempt-repo.js";
-import { PinRepository } from "../repo/pin-repo.js";
-import { syncBlocks } from "../utils/pin-file.js";
-import { AnchorRepository } from "../repo/anchor-repo.js";
-import { EdgeRepository } from "../repo/edge-repo.js";
-import { DocRepository } from "../repo/doc-repo.js";
-import { LearningUpsertOp as LearningUpsertOpSchema, FileLearningUpsertOp as FileLearningUpsertOpSchema, AttemptUpsertOp as AttemptUpsertOpSchema, PinUpsertOp as PinUpsertOpSchema, AnchorUpsertOp as AnchorUpsertOpSchema, EdgeUpsertOp as EdgeUpsertOpSchema, DocUpsertOp as DocUpsertOpSchema, DocLinkUpsertOp as DocLinkUpsertOpSchema, TaskDocLinkUpsertOp as TaskDocLinkUpsertOpSchema, InvariantUpsertOp as InvariantUpsertOpSchema, LabelUpsertOp as LabelUpsertOpSchema, LabelAssignmentUpsertOp as LabelAssignmentUpsertOpSchema, SyncOperation as SyncOperationSchema } from "../schemas/sync.js";
+import { dirname, resolve, basename } from "node:path";
+import { DatabaseError, ValidationError } from "../../errors.js";
+import { SqliteClient } from "../../db.js";
+import { TaskService } from "../../services/task-service.js";
+import { StreamService } from "../../services/stream-service.js";
+import { DependencyRepository } from "../../repo/dep-repo.js";
+import { LearningRepository } from "../../repo/learning-repo.js";
+import { FileLearningRepository } from "../../repo/file-learning-repo.js";
+import { AttemptRepository } from "../../repo/attempt-repo.js";
+import { PinRepository } from "../../repo/pin-repo.js";
+import { syncBlocks } from "../../utils/pin-file.js";
+import { resolvePathWithin } from "../../utils/file-path.js";
+import { AnchorRepository } from "../../repo/anchor-repo.js";
+import { EdgeRepository } from "../../repo/edge-repo.js";
+import { DocRepository } from "../../repo/doc-repo.js";
+import { LearningUpsertOp as LearningUpsertOpSchema, FileLearningUpsertOp as FileLearningUpsertOpSchema, AttemptUpsertOp as AttemptUpsertOpSchema, PinUpsertOp as PinUpsertOpSchema, AnchorUpsertOp as AnchorUpsertOpSchema, EdgeUpsertOp as EdgeUpsertOpSchema, DocUpsertOp as DocUpsertOpSchema, DocLinkUpsertOp as DocLinkUpsertOpSchema, TaskDocLinkUpsertOp as TaskDocLinkUpsertOpSchema, InvariantUpsertOp as InvariantUpsertOpSchema, LabelUpsertOp as LabelUpsertOpSchema, LabelAssignmentUpsertOp as LabelAssignmentUpsertOpSchema, TaskSyncOperation as TaskSyncOperationSchema } from "../../schemas/sync.js";
+import { SyncEventEnvelopeSchema } from "../../schemas/sync-events.js";
+import { generateUlid } from "../../utils/ulid.js";
+import { applyEntityImportContract } from "../../services/sync/entity-import.js";
+import { applyEntityExportContract } from "../../services/sync/entity-export.js";
+import { importEntityJsonl } from "../../services/sync/file-utils.js";
 /**
- * SyncService provides JSONL-based export/import for git-tracked task syncing.
+ * SyncService provides stream-event export/import for git-tracked task syncing.
  * See DD-009 for full specification.
  */
 export class SyncService extends Context.Tag("SyncService")() {
@@ -31,6 +39,11 @@ const DEFAULT_ANCHORS_JSONL_PATH = ".tx/anchors.jsonl";
 const DEFAULT_EDGES_JSONL_PATH = ".tx/edges.jsonl";
 const DEFAULT_DOCS_JSONL_PATH = ".tx/docs.jsonl";
 const DEFAULT_LABELS_JSONL_PATH = ".tx/labels.jsonl";
+const DEFAULT_STREAMS_DIR = ".tx/streams";
+const DEFAULT_SYNC_WATERMARK_KEY = "last_import_at";
+const FULL_EXPORT_LIMIT = 1_000_000_000;
+const MAX_SYNC_JSONL_FILE_BYTES = 64 * 1024 * 1024;
+const MAX_STREAM_IMPORT_EVENTS = 250_000;
 /**
  * Compute a content hash for cross-machine dedup.
  * Entities with auto-increment IDs use this to identify duplicates.
@@ -45,6 +58,101 @@ const sqliteToIso = (s) => {
         return s.replace(" ", "T") + ".000Z";
     return s;
 };
+const V1_TO_SYNC_TYPE = {
+    upsert: "task.upsert",
+    delete: "task.delete",
+    dep_add: "dep.add",
+    dep_remove: "dep.remove",
+    learning_upsert: "learning.upsert",
+    learning_delete: "learning.delete",
+    file_learning_upsert: "file_learning.upsert",
+    file_learning_delete: "file_learning.delete",
+    attempt_upsert: "attempt.upsert",
+    pin_upsert: "pin.upsert",
+    pin_delete: "pin.delete",
+    anchor_upsert: "anchor.upsert",
+    anchor_delete: "anchor.delete",
+    edge_upsert: "edge.upsert",
+    edge_delete: "edge.delete",
+    doc_upsert: "doc.upsert",
+    doc_delete: "doc.delete",
+    doc_link_upsert: "doc_link.upsert",
+    task_doc_link_upsert: "task_doc_link.upsert",
+    invariant_upsert: "invariant.upsert",
+    label_upsert: "label.upsert",
+    label_assignment_upsert: "label_assignment.upsert",
+};
+const entityIdFromV1Op = (op) => {
+    const kind = typeof op.op === "string" ? op.op : "";
+    switch (kind) {
+        case "dep_add":
+        case "dep_remove":
+            return `${String(op.blockerId)}:${String(op.blockedId)}`;
+        case "learning_upsert":
+        case "learning_delete":
+        case "file_learning_upsert":
+        case "file_learning_delete":
+        case "attempt_upsert":
+        case "anchor_upsert":
+        case "anchor_delete":
+        case "edge_upsert":
+        case "edge_delete":
+        case "doc_upsert":
+        case "doc_delete":
+        case "label_upsert":
+            return String(op.contentHash ?? op.id ?? "");
+        case "doc_link_upsert":
+            return String(op.contentHash ?? op.id ?? "");
+        case "task_doc_link_upsert":
+            return String(op.contentHash ?? op.id ?? "");
+        case "label_assignment_upsert":
+            return String(op.contentHash ?? "");
+        default:
+            return String(op.id ?? op.contentHash ?? "");
+    }
+};
+const opToSyncEventType = (op) => {
+    const v1Op = typeof op.op === "string" ? op.op : "";
+    return V1_TO_SYNC_TYPE[v1Op] ?? null;
+};
+const getTsFromOp = (op) => typeof op.ts === "string" ? op.ts : new Date().toISOString();
+const getEventIdFromOp = (op) => typeof op.eventId === "string" ? op.eventId : (typeof op.__event_id === "string" ? op.__event_id : "");
+const compareOpOrder = (a, b) => {
+    const t = getTsFromOp(a).localeCompare(getTsFromOp(b));
+    if (t !== 0)
+        return t;
+    const eventCmp = getEventIdFromOp(a).localeCompare(getEventIdFromOp(b));
+    if (eventCmp !== 0)
+        return eventCmp;
+    return 0;
+};
+const compareSyncOrder = (a, b) => {
+    const t = a.ts.localeCompare(b.ts);
+    if (t !== 0)
+        return t;
+    return (a.eventId ?? "").localeCompare(b.eventId ?? "");
+};
+const toSyncEvent = (op, streamId, seq) => {
+    const type = opToSyncEventType(op);
+    if (!type)
+        return null;
+    return {
+        event_id: generateUlid(),
+        stream_id: streamId,
+        seq,
+        ts: getTsFromOp(op),
+        type,
+        entity_id: entityIdFromV1Op(op),
+        v: 2,
+        payload: op,
+    };
+};
+const syncEventToV1Op = (event) => {
+    if (!event.payload || typeof event.payload !== "object")
+        return null;
+    const payload = event.payload;
+    return typeof payload.op === "string" ? payload : null;
+};
 /**
  * Empty entity import result for early returns.
  */
@@ -58,6 +166,123 @@ const EMPTY_IMPORT_RESULT = {
     conflicts: 0,
     dependencies: { added: 0, removed: 0, skipped: 0, failures: [] }
 };
+const emptyV1Buckets = () => ({
+    tasks: [],
+    learnings: [],
+    fileLearnings: [],
+    attempts: [],
+    pins: [],
+    anchors: [],
+    edges: [],
+    docs: [],
+    labels: [],
+});
+const bucketForOp = (opName) => {
+    if (opName === "upsert" || opName === "delete" || opName === "dep_add" || opName === "dep_remove")
+        return "tasks";
+    if (opName === "learning_upsert" || opName === "learning_delete")
+        return "learnings";
+    if (opName === "file_learning_upsert" || opName === "file_learning_delete")
+        return "fileLearnings";
+    if (opName === "attempt_upsert")
+        return "attempts";
+    if (opName === "pin_upsert" || opName === "pin_delete")
+        return "pins";
+    if (opName === "anchor_upsert" || opName === "anchor_delete")
+        return "anchors";
+    if (opName === "edge_upsert" || opName === "edge_delete")
+        return "edges";
+    if (opName === "doc_upsert" || opName === "doc_delete" || opName === "doc_link_upsert" || opName === "task_doc_link_upsert" || opName === "invariant_upsert")
+        return "docs";
+    if (opName === "label_upsert" || opName === "label_assignment_upsert")
+        return "labels";
+    return null;
+};
+const stateCategoryForOp = (opName) => {
+    if (opName === "upsert" || opName === "delete")
+        return "task";
+    if (opName === "dep_add" || opName === "dep_remove")
+        return "dep";
+    if (opName === "learning_upsert" || opName === "learning_delete")
+        return "learning";
+    if (opName === "file_learning_upsert" || opName === "file_learning_delete")
+        return "file_learning";
+    if (opName === "attempt_upsert")
+        return "attempt";
+    if (opName === "pin_upsert" || opName === "pin_delete")
+        return "pin";
+    if (opName === "anchor_upsert" || opName === "anchor_delete")
+        return "anchor";
+    if (opName === "edge_upsert" || opName === "edge_delete")
+        return "edge";
+    if (opName === "doc_upsert" || opName === "doc_delete")
+        return "doc";
+    if (opName === "doc_link_upsert")
+        return "doc_link";
+    if (opName === "task_doc_link_upsert")
+        return "task_doc_link";
+    if (opName === "invariant_upsert")
+        return "invariant";
+    if (opName === "label_upsert")
+        return "label";
+    if (opName === "label_assignment_upsert")
+        return "label_assignment";
+    return null;
+};
+const stateCategoryForSyncType = (syncType) => {
+    if (syncType === "task.upsert" || syncType === "task.delete")
+        return "task";
+    if (syncType === "dep.add" || syncType === "dep.remove")
+        return "dep";
+    if (syncType === "learning.upsert" || syncType === "learning.delete")
+        return "learning";
+    if (syncType === "file_learning.upsert" || syncType === "file_learning.delete")
+        return "file_learning";
+    if (syncType === "attempt.upsert")
+        return "attempt";
+    if (syncType === "pin.upsert" || syncType === "pin.delete")
+        return "pin";
+    if (syncType === "anchor.upsert" || syncType === "anchor.delete")
+        return "anchor";
+    if (syncType === "edge.upsert" || syncType === "edge.delete")
+        return "edge";
+    if (syncType === "doc.upsert" || syncType === "doc.delete")
+        return "doc";
+    if (syncType === "doc_link.upsert")
+        return "doc_link";
+    if (syncType === "task_doc_link.upsert")
+        return "task_doc_link";
+    if (syncType === "invariant.upsert")
+        return "invariant";
+    if (syncType === "label.upsert")
+        return "label";
+    if (syncType === "label_assignment.upsert")
+        return "label_assignment";
+    return null;
+};
+const isRemovalSyncType = (syncType) => syncType === "task.delete" ||
+    syncType === "dep.remove" ||
+    syncType === "learning.delete" ||
+    syncType === "file_learning.delete" ||
+    syncType === "pin.delete" ||
+    syncType === "anchor.delete" ||
+    syncType === "edge.delete" ||
+    syncType === "doc.delete";
+const stateKeyForSyncEvent = (syncType, entityId) => {
+    if (typeof entityId !== "string" || entityId.length === 0)
+        return null;
+    const category = stateCategoryForSyncType(syncType);
+    if (!category)
+        return null;
+    return `${category}:${entityId}`;
+};
+const stateKeyForOp = (op) => {
+    const opName = typeof op.op === "string" ? op.op : "";
+    const category = stateCategoryForOp(opName);
+    if (!category)
+        return null;
+    return `${category}:${entityIdFromV1Op(op)}`;
+};
 /**
  * Topologically sort task operations so parents are processed before children.
  * This ensures foreign key constraints are satisfied during import.
@@ -402,64 +627,30 @@ const labelAssignmentToUpsertOp = (row, labelNameMap) => {
     };
 };
 /**
- * Generic helper: parse a JSONL file, validate with schema, dedup by contentHash,
- * filter against existing entities, and insert new ones via caller-provided batch function.
- * Returns EntityImportResult with imported/skipped counts.
+ * Check if a file exists without blocking the event loop.
  */
-const importEntityJsonl = (filePath, schema, existingHashes, insertBatch) => Effect.gen(function* () {
-    const importFileExists = yield* fileExists(filePath);
-    if (!importFileExists) {
-        return EMPTY_ENTITY_IMPORT_RESULT;
+const fileExists = (filePath) => Effect.promise(() => access(filePath).then(() => true).catch(() => false));
+const readUtf8FileWithLimit = (filePath, maxBytes = MAX_SYNC_JSONL_FILE_BYTES) => Effect.gen(function* () {
+    const fileStats = yield* Effect.tryPromise({
+        try: () => stat(filePath),
+        catch: (cause) => new DatabaseError({ cause })
+    });
+    if (fileStats.size > maxBytes) {
+        return yield* Effect.fail(new ValidationError({
+            reason: `Sync import file exceeds ${maxBytes} bytes: ${filePath}`
+        }));
     }
     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 EMPTY_ENTITY_IMPORT_RESULT;
-    }
-    // Parse and dedup by contentHash (keep latest by timestamp)
-    const states = new Map();
-    for (const line of lines) {
-        const parsed = yield* Effect.try({
-            try: () => JSON.parse(line),
-            catch: (cause) => new ValidationError({ reason: `Invalid JSON: ${cause}` })
-        });
-        const op = yield* Effect.try({
-            try: () => Schema.decodeUnknownSync(schema)(parsed),
-            catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
-        });
-        const existing = states.get(op.contentHash);
-        if (!existing || op.ts > existing.ts) {
-            states.set(op.contentHash, op);
-        }
+    if (Buffer.byteLength(content, "utf8") > maxBytes) {
+        return yield* Effect.fail(new ValidationError({
+            reason: `Sync import file exceeds ${maxBytes} bytes: ${filePath}`
+        }));
     }
-    // Filter to new entities only (not already in DB)
-    const newOps = [];
-    let skipped = 0;
-    for (const op of states.values()) {
-        if (existingHashes.has(op.contentHash)) {
-            skipped++;
-        }
-        else {
-            newOps.push(op);
-        }
-    }
-    if (newOps.length === 0) {
-        return { imported: 0, skipped };
-    }
-    // Insert via caller-provided batch function (handles transaction)
-    const imported = yield* Effect.try({
-        try: () => insertBatch(newOps),
-        catch: (cause) => new DatabaseError({ cause })
-    });
-    return { imported, skipped };
+    return content;
 });
-/**
- * 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.
@@ -476,6 +667,7 @@ const atomicWrite = (filePath, content) => Effect.tryPromise({
 });
 export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* () {
     const taskService = yield* TaskService;
+    const streamService = yield* StreamService;
     const depRepo = yield* DependencyRepository;
     const db = yield* SqliteClient;
     const learningRepo = yield* LearningRepository;
@@ -500,29 +692,336 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
         },
         catch: (cause) => new DatabaseError({ cause })
     });
-    const syncService = {
-        export: (path) => Effect.gen(function* () {
-            const filePath = resolve(path ?? DEFAULT_JSONL_PATH);
-            // Get all tasks and dependencies (explicit high limit for full export)
-            const tasks = yield* taskService.list();
-            const deps = yield* depRepo.getAll(100_000);
-            // Convert to sync operations
-            const taskOps = tasks.map(taskToUpsertOp);
-            const depOps = deps.map(depToAddOp);
-            // Combine and sort by timestamp
-            const allOps = [...taskOps, ...depOps].sort((a, b) => a.ts.localeCompare(b.ts));
-            // Convert to JSONL format (one JSON object per line)
-            const jsonl = allOps.map(op => JSON.stringify(op)).join("\n");
-            // Write atomically
-            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
-            // Record export time
-            yield* setConfig("last_export", new Date().toISOString());
-            return {
-                opCount: allOps.length,
-                path: filePath
-            };
-        }),
-        import: (path) => Effect.gen(function* () {
+    const setWatermark = (key, value) => Effect.try({
+        try: () => {
+            db.prepare("INSERT OR REPLACE INTO sync_watermark (key, value) VALUES (?, ?)").run(key, value);
+        },
+        catch: (cause) => new DatabaseError({ cause })
+    });
+    const touchStreamProgress = (streamId, lastSeq, lastEventAt) => {
+        db.prepare(`INSERT INTO sync_streams (stream_id, created_at, last_seq, last_event_at)
+         VALUES (?, datetime('now'), ?, ?)
+         ON CONFLICT(stream_id) DO UPDATE SET
+           last_seq = CASE
+             WHEN excluded.last_seq > sync_streams.last_seq THEN excluded.last_seq
+             ELSE sync_streams.last_seq
+           END,
+           last_event_at = CASE
+             WHEN excluded.last_event_at IS NOT NULL THEN excluded.last_event_at
+             ELSE sync_streams.last_event_at
+           END`).run(streamId, lastSeq, lastEventAt ?? null);
+    };
+    const runWriteTransaction = db.transaction((body) => body());
+    const withWriteTransaction = (body) => {
+        if (db.inTransaction) {
+            return runWriteTransaction(body);
+        }
+        return runWriteTransaction.immediate(body);
+    };
+    const readJsonlRecords = (filePath) => Effect.gen(function* () {
+        const exists = yield* fileExists(filePath);
+        if (!exists)
+            return [];
+        const content = yield* readUtf8FileWithLimit(filePath);
+        const lines = content.trim().split("\n").filter(Boolean);
+        const records = [];
+        for (const line of lines) {
+            const parsed = yield* Effect.try({
+                try: () => JSON.parse(line),
+                catch: (cause) => new ValidationError({ reason: `Invalid JSON: ${cause}` })
+            });
+            if (!parsed || typeof parsed !== "object") {
+                return yield* Effect.fail(new ValidationError({ reason: "JSONL line is not an object" }));
+            }
+            records.push(parsed);
+        }
+        return records;
+    });
+    const loadEventsFromStreams = (mode) => Effect.gen(function* () {
+        const streamsRoot = resolve(DEFAULT_STREAMS_DIR);
+        const rootExists = yield* fileExists(streamsRoot);
+        if (!rootExists) {
+            return { events: [], streamCount: 0, maxSeqByStream: new Map() };
+        }
+        const entries = yield* Effect.tryPromise({
+            try: () => readdir(streamsRoot, { withFileTypes: true }),
+            catch: (cause) => new DatabaseError({ cause })
+        });
+        const streamDirs = entries.filter(entry => entry.isDirectory());
+        const events = [];
+        const maxSeqByStream = new Map();
+        for (const dir of streamDirs) {
+            const streamId = dir.name;
+            const knownLastSeq = mode === "incremental"
+                ? (yield* Effect.try({
+                    try: () => db.prepare("SELECT last_seq FROM sync_streams WHERE stream_id = ?").get(streamId)?.last_seq ?? 0,
+                    catch: (cause) => new DatabaseError({ cause })
+                }))
+                : 0;
+            const dirPath = resolve(streamsRoot, streamId);
+            const files = yield* Effect.tryPromise({
+                try: () => readdir(dirPath),
+                catch: (cause) => new DatabaseError({ cause })
+            });
+            const eventFiles = files
+                .filter(name => /^events-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name))
+                .sort();
+            for (const file of eventFiles) {
+                const filePath = resolve(dirPath, file);
+                const lines = (yield* readJsonlRecords(filePath));
+                for (const line of lines) {
+                    const event = yield* Effect.try({
+                        try: () => Schema.decodeUnknownSync(SyncEventEnvelopeSchema)(line),
+                        catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
+                    });
+                    if (event.stream_id !== streamId) {
+                        return yield* Effect.fail(new ValidationError({
+                            reason: `Event stream mismatch in ${basename(filePath)}: expected ${streamId}, got ${event.stream_id}`
+                        }));
+                    }
+                    if (event.seq <= knownLastSeq)
+                        continue;
+                    if (events.length >= MAX_STREAM_IMPORT_EVENTS) {
+                        return yield* Effect.fail(new ValidationError({
+                            reason: `Stream import exceeds ${MAX_STREAM_IMPORT_EVENTS} events; split stream files or run incremental imports more frequently`
+                        }));
+                    }
+                    events.push(event);
+                    const currentMax = maxSeqByStream.get(streamId) ?? 0;
+                    if (event.seq > currentMax)
+                        maxSeqByStream.set(streamId, event.seq);
+                }
+            }
+        }
+        events.sort((a, b) => {
+            const t = a.ts.localeCompare(b.ts);
+            return t !== 0 ? t : a.event_id.localeCompare(b.event_id);
+        });
+        return {
+            events,
+            streamCount: streamDirs.length,
+            maxSeqByStream
+        };
+    });
+    const bucketEventsToV1Ops = (events) => {
+        const buckets = emptyV1Buckets();
+        for (const event of events) {
+            const base = syncEventToV1Op(event);
+            if (!base)
+                continue;
+            const op = { ...base, eventId: event.event_id };
+            const name = typeof op.op === "string" ? op.op : "";
+            const bucket = bucketForOp(name);
+            if (!bucket)
+                continue;
+            buckets[bucket].push(op);
+        }
+        const sortByTs = (ops) => ops.sort(compareOpOrder);
+        sortByTs(buckets.tasks);
+        sortByTs(buckets.learnings);
+        sortByTs(buckets.fileLearnings);
+        sortByTs(buckets.attempts);
+        sortByTs(buckets.pins);
+        sortByTs(buckets.anchors);
+        sortByTs(buckets.edges);
+        sortByTs(buckets.docs);
+        sortByTs(buckets.labels);
+        return buckets;
+    };
+    const writeBucketsToTempFiles = (buckets) => Effect.gen(function* () {
+        const dir = resolve(".tx", ".sync-temp", `${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        yield* Effect.tryPromise({
+            try: () => mkdir(dir, { recursive: true }),
+            catch: (cause) => new DatabaseError({ cause })
+        });
+        const writeBucket = (name, ops) => Effect.gen(function* () {
+            const filePath = resolve(dir, name);
+            if (ops.length === 0) {
+                yield* atomicWrite(filePath, "");
+            }
+            else {
+                const jsonl = ops.map(op => JSON.stringify(op)).join("\n");
+                yield* atomicWrite(filePath, `${jsonl}\n`);
+            }
+            return filePath;
+        });
+        const tasksPath = yield* writeBucket("tasks.jsonl", buckets.tasks);
+        const learningsPath = yield* writeBucket("learnings.jsonl", buckets.learnings);
+        const fileLearningsPath = yield* writeBucket("file-learnings.jsonl", buckets.fileLearnings);
+        const attemptsPath = yield* writeBucket("attempts.jsonl", buckets.attempts);
+        const pinsPath = yield* writeBucket("pins.jsonl", buckets.pins);
+        const anchorsPath = yield* writeBucket("anchors.jsonl", buckets.anchors);
+        const edgesPath = yield* writeBucket("edges.jsonl", buckets.edges);
+        const docsPath = yield* writeBucket("docs.jsonl", buckets.docs);
+        const labelsPath = yield* writeBucket("labels.jsonl", buckets.labels);
+        return {
+            dir,
+            tasksPath,
+            learningsPath,
+            fileLearningsPath,
+            attemptsPath,
+            pinsPath,
+            anchorsPath,
+            edgesPath,
+            docsPath,
+            labelsPath,
+        };
+    });
+    const clearMaterializedTables = () => Effect.try({
+        try: () => {
+            withWriteTransaction(() => {
+                db.prepare("DELETE FROM task_label_assignments").run();
+                db.prepare("DELETE FROM task_labels").run();
+                db.prepare("DELETE FROM invariant_checks").run();
+                db.prepare("DELETE FROM invariants").run();
+                db.prepare("DELETE FROM task_doc_links").run();
+                db.prepare("DELETE FROM doc_links").run();
+                db.prepare("DELETE FROM docs").run();
+                db.prepare("DELETE FROM learning_edges").run();
+                db.prepare("DELETE FROM learning_anchors").run();
+                db.prepare("DELETE FROM context_pins").run();
+                db.prepare("DELETE FROM attempts").run();
+                db.prepare("DELETE FROM file_learnings").run();
+                db.prepare("DELETE FROM learnings").run();
+                db.prepare("DELETE FROM task_dependencies").run();
+                db.prepare("DELETE FROM tasks").run();
+            });
+        },
+        catch: (cause) => new DatabaseError({ cause })
+    });
+    const cleanupTempDir = (dir) => Effect.promise(() => rm(dir, { recursive: true, force: true }).then(() => undefined).catch(() => undefined));
+    const collectCurrentOpsForSync = () => Effect.gen(function* () {
+        const tasks = yield* taskService.list();
+        const deps = yield* depRepo.getAll(100_000);
+        const taskOps = tasks.map(taskToUpsertOp);
+        const depOps = deps.map(depToAddOp);
+        const learnings = yield* learningRepo.findAll(FULL_EXPORT_LIMIT);
+        const learningOps = learnings.map(learningToUpsertOp);
+        const learningHashMap = new Map();
+        for (const l of learnings) {
+            learningHashMap.set(l.id, contentHash(l.content, l.sourceType));
+        }
+        const fileLearnings = yield* fileLearningRepo.findAll(FULL_EXPORT_LIMIT);
+        const fileLearningOps = fileLearnings.map(fileLearningToUpsertOp);
+        const attempts = yield* attemptRepo.findAll();
+        const attemptOps = attempts.map(attemptToUpsertOp);
+        const pins = yield* pinRepo.findAll();
+        const pinOps = [...pins].map(pinToUpsertOp);
+        const anchors = yield* anchorRepo.findAll(FULL_EXPORT_LIMIT);
+        const anchorOps = anchors.map(anchor => anchorToUpsertOp(anchor, learningHashMap));
+        const edges = yield* edgeRepo.findAll(FULL_EXPORT_LIMIT);
+        const edgeOps = edges
+            .filter(edge => edge.invalidatedAt === null)
+            .map(edgeToUpsertOp);
+        const docs = yield* docRepo.findAll();
+        const docKeyMap = new Map();
+        for (const d of docs) {
+            docKeyMap.set(d.id, `${d.name}:${d.version}`);
+        }
+        const docOps = docs.map(d => docToUpsertOp(d, docKeyMap));
+        const docLinks = yield* docRepo.getAllLinks();
+        const docLinkOps = docLinks
+            .map(link => docLinkToUpsertOp(link, docKeyMap))
+            .filter((op) => op !== null);
+        const taskDocLinkRows = yield* Effect.try({
+            try: () => db.prepare("SELECT * FROM task_doc_links").all(),
+            catch: (cause) => new DatabaseError({ cause })
+        });
+        const taskDocLinkOps = taskDocLinkRows
+            .map(row => taskDocLinkToUpsertOp({ id: row.id, taskId: row.task_id, docId: row.doc_id, linkType: row.link_type, createdAt: new Date(row.created_at) }, docKeyMap))
+            .filter((op) => op !== null);
+        const invariants = yield* docRepo.findInvariants();
+        const invariantOps = invariants
+            .map(inv => invariantToUpsertOp(inv, docKeyMap))
+            .filter((op) => op !== null);
+        const labelRows = yield* Effect.try({
+            try: () => db.prepare("SELECT * FROM task_labels").all(),
+            catch: (cause) => new DatabaseError({ cause })
+        });
+        const labelNameMap = new Map();
+        for (const l of labelRows) {
+            labelNameMap.set(l.id, l.name);
+        }
+        const labelOps = labelRows.map(labelRowToUpsertOp);
+        const assignmentRows = yield* Effect.try({
+            try: () => db.prepare("SELECT * FROM task_label_assignments").all(),
+            catch: (cause) => new DatabaseError({ cause })
+        });
+        const labelAssignmentOps = assignmentRows
+            .map(a => labelAssignmentToUpsertOp(a, labelNameMap))
+            .filter((op) => op !== null);
+        const all = [
+            ...taskOps,
+            ...depOps,
+            ...learningOps,
+            ...fileLearningOps,
+            ...attemptOps,
+            ...pinOps,
+            ...anchorOps,
+            ...edgeOps,
+            ...docOps,
+            ...docLinkOps,
+            ...taskDocLinkOps,
+            ...invariantOps,
+            ...labelOps,
+            ...labelAssignmentOps,
+        ];
+        all.sort(compareOpOrder);
+        return all;
+    });
+    const collectLegacyTaskOpsForSync = () => Effect.gen(function* () {
+        const tasks = yield* taskService.list();
+        const deps = yield* depRepo.getAll(100_000);
+        const taskOps = tasks.map(taskToUpsertOp);
+        const depOps = deps.map(depToAddOp);
+        const all = [...taskOps, ...depOps];
+        all.sort(compareOpOrder);
+        return all;
+    });
+    const syncPinsToTargetFiles = () => Effect.gen(function* () {
+        const allPins = yield* pinRepo.findAll();
+        const targetFiles = yield* pinRepo.getTargetFiles();
+        const pinMap = new Map();
+        for (const pin of allPins) {
+            pinMap.set(pin.id, pin.content);
+        }
+        yield* Effect.try({
+            try: () => {
+                for (const targetFile of targetFiles) {
+                    const projectRoot = process.cwd();
+                    const resolvedPath = resolvePathWithin(projectRoot, targetFile, {
+                        useRealpath: true
+                    });
+                    if (!resolvedPath)
+                        continue;
+                    let fileContent = "";
+                    try {
+                        fileContent = readFileSync(resolvedPath, "utf-8");
+                    }
+                    catch { /* file doesn't exist yet */ }
+                    const updated = syncBlocks(fileContent, pinMap);
+                    if (updated !== fileContent) {
+                        const dir = dirname(resolvedPath);
+                        mkdirSync(dir, { recursive: true });
+                        const tempPath = `${resolvedPath}.tmp.${Date.now()}.${process.pid}`;
+                        writeFileSync(tempPath, updated, "utf-8");
+                        try {
+                            renameSync(tempPath, resolvedPath);
+                        }
+                        finally {
+                            try {
+                                unlinkSync(tempPath);
+                            }
+                            catch { /* ignore cleanup error */ }
+                        }
+                    }
+                }
+            },
+            catch: (cause) => new DatabaseError({ cause })
+        });
+    });
+    const syncService = applyEntityImportContract(applyEntityExportContract({
+        importTaskOps: (path) => Effect.gen(function* () {
             const filePath = resolve(path ?? DEFAULT_JSONL_PATH);
             // Check if file exists (outside transaction - no DB access)
             const importFileExists = yield* fileExists(filePath);
@@ -530,10 +1029,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                 return EMPTY_IMPORT_RESULT;
             }
             // 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 content = yield* readUtf8FileWithLimit(filePath);
             const lines = content.trim().split("\n").filter(Boolean);
             if (lines.length === 0) {
                 return EMPTY_IMPORT_RESULT;
@@ -548,7 +1044,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                     catch: (cause) => new ValidationError({ reason: `Invalid JSON: ${cause}` })
                 });
                 const op = yield* Effect.try({
-                    try: () => Schema.decodeUnknownSync(SyncOperationSchema)(parsed),
+                    try: () => Schema.decodeUnknownSync(TaskSyncOperationSchema)(parsed),
                     catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
                 });
                 ops.push(op);
@@ -559,15 +1055,15 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             for (const op of ops) {
                 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, ts: op.ts });
+                    if (!existing || compareSyncOrder(op, existing) > 0) {
+                        taskStates.set(op.id, { op: op, ts: op.ts, eventId: op.eventId });
                     }
                 }
                 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, ts: op.ts });
+                    if (!existing || compareSyncOrder(op, existing) > 0) {
+                        depStates.set(key, { op: op, ts: op.ts, eventId: op.eventId });
                     }
                 }
             }
@@ -601,15 +1097,8 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             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: () => {
+            return yield* Effect.try({
+                try: () => withWriteTransaction(() => {
                     let imported = 0;
                     let skipped = 0;
                     let conflicts = 0;
@@ -729,16 +1218,14 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                         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}`);
+                        throw new ValidationError({ reason: `Sync import rolled back: ${depFailures.length} dependency failure(s): ${details}` });
                     }
                     // 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.
+                    // Re-read synchronously while holding the DB write lock.
                     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.");
+                        throw new ValidationError({ reason: "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());
@@ -753,153 +1240,76 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                             failures: depFailures
                         }
                     };
-                },
-                catch: (cause) => new DatabaseError({ cause })
-            }), 
-            // Release: Commit on success, rollback on failure
-            (_, exit) => Effect.sync(() => {
-                if (Exit.isSuccess(exit)) {
-                    try {
-                        db.exec("COMMIT");
-                    }
-                    catch {
-                        // COMMIT failed — roll back to prevent a stuck open transaction
-                        try {
-                            db.exec("ROLLBACK");
-                        }
-                        catch { /* already rolled back */ }
-                    }
-                }
-                else {
-                    try {
-                        db.exec("ROLLBACK");
-                    }
-                    catch { /* no active transaction */ }
-                }
-            }));
+                }),
+                catch: (cause) => cause instanceof ValidationError ? cause : new DatabaseError({ cause })
+            });
         }),
         status: () => Effect.gen(function* () {
-            const filePath = resolve(DEFAULT_JSONL_PATH);
-            // 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({
+            const eventOpCount = yield* Effect.try({
                 try: () => {
-                    const row = db.prepare("SELECT COUNT(*) as cnt FROM task_dependencies").get();
+                    const row = db.prepare("SELECT COUNT(*) as cnt FROM sync_events").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;
-            const jsonlFileExists = yield* fileExists(filePath);
-            if (jsonlFileExists) {
-                // Get file modification time as lastExport
-                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.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");
             const lastImportConfig = yield* getConfig("last_import");
-            const lastExportDate = lastExportConfig && lastExportConfig !== "" ? new Date(lastExportConfig) : lastExport;
+            const lastExportDate = lastExportConfig && lastExportConfig !== "" ? new Date(lastExportConfig) : null;
             const lastImportDate = lastImportConfig && lastImportConfig !== "" ? new Date(lastImportConfig) : null;
             // Get auto-sync status
             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 && !jsonlFileExists) {
-                // No JSONL file but tasks exist → dirty
-                isDirty = true;
+            // Dirty detection includes timestamp drift and state-shape drift.
+            // Uses sync_events table (not filesystem scans) for exported state.
+            const currentOps = yield* collectCurrentOpsForSync();
+            const currentStateKeys = new Set();
+            for (const op of currentOps) {
+                const key = stateKeyForOp(op);
+                if (key)
+                    currentStateKeys.add(key);
             }
-            else if (dbTaskCount > 0 || dbDepCount > 0) {
-                if (lastExportDate === null) {
-                    // Tasks/deps exist but never exported → dirty
-                    isDirty = true;
+            const latestExportedState = new Map();
+            const exportedRows = yield* Effect.try({
+                try: () => db.prepare("SELECT event_id, ts, type, entity_id FROM sync_events").all(),
+                catch: (cause) => new DatabaseError({ cause })
+            });
+            for (const row of exportedRows) {
+                const syncType = typeof row.type === "string" ? row.type : "";
+                const key = stateKeyForSyncEvent(syncType, row.entity_id);
+                if (!key)
+                    continue;
+                const next = { syncType, ts: row.ts, eventId: row.event_id };
+                const existing = latestExportedState.get(key);
+                if (!existing || compareSyncOrder(next, existing) > 0) {
+                    latestExportedState.set(key, next);
                 }
-                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;
+            }
+            const exportedStateKeys = new Set();
+            for (const [key, state] of latestExportedState.entries()) {
+                if (!isRemovalSyncType(state.syncType)) {
+                    exportedStateKeys.add(key);
                 }
             }
+            const stateMismatch = currentStateKeys.size !== exportedStateKeys.size ||
+                [...currentStateKeys].some((key) => !exportedStateKeys.has(key)) ||
+                [...exportedStateKeys].some((key) => !currentStateKeys.has(key));
+            const hasLocalState = currentStateKeys.size > 0;
+            const lastOpTs = currentOps.reduce((max, op) => {
+                const ts = typeof op.ts === "string" ? op.ts : null;
+                if (!ts)
+                    return max;
+                if (max === null)
+                    return ts;
+                return ts > max ? ts : max;
+            }, null);
+            const hasStateWithoutExport = lastExportDate === null && (hasLocalState || exportedStateKeys.size > 0);
+            const hasNewerProjectedState = lastExportDate !== null && lastOpTs !== null && lastOpTs > lastExportDate.toISOString();
+            const isDirty = hasStateWithoutExport || hasNewerProjectedState || stateMismatch;
             return {
                 dbTaskCount,
-                jsonlOpCount,
+                eventOpCount,
                 lastExport: lastExportDate,
                 lastImport: lastImportDate,
                 isDirty,
@@ -912,74 +1322,6 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const value = yield* getConfig("auto_sync");
             return value === "true";
         }),
-        compact: (path) => Effect.gen(function* () {
-            const filePath = resolve(path ?? DEFAULT_JSONL_PATH);
-            // Check if file exists
-            const compactFileExists = yield* fileExists(filePath);
-            if (!compactFileExists) {
-                return { before: 0, after: 0 };
-            }
-            // Read and parse JSONL file
-            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 { before: 0, after: 0 };
-            }
-            const before = lines.length;
-            // Parse and deduplicate - keep only latest state per entity
-            const taskStates = new Map();
-            const depStates = new Map();
-            for (const line of lines) {
-                const parsed = yield* Effect.try({
-                    try: () => JSON.parse(line),
-                    catch: (cause) => new ValidationError({ reason: `Invalid JSON: ${cause}` })
-                });
-                const op = yield* Effect.try({
-                    try: () => Schema.decodeUnknownSync(SyncOperationSchema)(parsed),
-                    catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
-                });
-                if (op.op === "upsert" || op.op === "delete") {
-                    const taskOp = op;
-                    const existing = taskStates.get(taskOp.id);
-                    if (!existing || taskOp.ts > existing.ts) {
-                        taskStates.set(taskOp.id, op);
-                    }
-                }
-                else if (op.op === "dep_add" || op.op === "dep_remove") {
-                    const depOp = op;
-                    const key = `${depOp.blockerId}:${depOp.blockedId}`;
-                    const existing = depStates.get(key);
-                    if (!existing || depOp.ts > existing.ts) {
-                        depStates.set(key, op);
-                    }
-                }
-            }
-            // Rebuild compacted JSONL, excluding deleted tasks and removed deps
-            const compacted = [];
-            for (const op of taskStates.values()) {
-                // Only keep upserts, skip deletes (tombstones)
-                if (op.op === "upsert") {
-                    compacted.push(op);
-                }
-            }
-            for (const op of depStates.values()) {
-                // Only keep dep_adds, skip dep_removes
-                if (op.op === "dep_add") {
-                    compacted.push(op);
-                }
-            }
-            // Sort by timestamp for deterministic output
-            compacted.sort((a, b) => a.ts.localeCompare(b.ts));
-            // Write compacted JSONL atomically
-            const newContent = compacted.map(op => JSON.stringify(op)).join("\n");
-            yield* atomicWrite(filePath, newContent + (newContent.length > 0 ? "\n" : ""));
-            return { before, after: compacted.length };
-        }),
-        setLastExport: (timestamp) => setConfig("last_export", timestamp.toISOString()),
-        setLastImport: (timestamp) => setConfig("last_import", timestamp.toISOString()),
         exportLearnings: (path) => Effect.gen(function* () {
             const filePath = resolve(path ?? DEFAULT_LEARNINGS_JSONL_PATH);
             const learnings = yield* learningRepo.findAll();
@@ -995,23 +1337,14 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const existingHashes = new Set(existing.map(l => contentHash(l.content, l.sourceType)));
             const insertStmt = db.prepare("INSERT INTO learnings (content, source_type, source_ref, created_at, keywords, category) VALUES (?, ?, ?, ?, ?, ?)");
             return yield* importEntityJsonl(filePath, LearningUpsertOpSchema, existingHashes, (ops) => {
-                db.exec("BEGIN IMMEDIATE");
-                try {
+                return withWriteTransaction(() => {
                     let count = 0;
                     for (const op of ops) {
                         insertStmt.run(op.data.content, op.data.sourceType, op.data.sourceRef, op.ts, JSON.stringify(op.data.keywords), op.data.category);
                         count++;
                     }
-                    db.exec("COMMIT");
                     return count;
-                }
-                catch (e) {
-                    try {
-                        db.exec("ROLLBACK");
-                    }
-                    catch { /* no active transaction */ }
-                    throw e;
-                }
+                });
             });
         }),
         exportFileLearnings: (path) => Effect.gen(function* () {
@@ -1029,23 +1362,14 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const existingHashes = new Set(existing.map(fl => contentHash(fl.filePattern, fl.note)));
             const insertStmt = db.prepare("INSERT INTO file_learnings (file_pattern, note, task_id, created_at) VALUES (?, ?, ?, ?)");
             return yield* importEntityJsonl(filePath, FileLearningUpsertOpSchema, existingHashes, (ops) => {
-                db.exec("BEGIN IMMEDIATE");
-                try {
+                return withWriteTransaction(() => {
                     let count = 0;
                     for (const op of ops) {
                         insertStmt.run(op.data.filePattern, op.data.note, op.data.taskId, op.ts);
                         count++;
                     }
-                    db.exec("COMMIT");
                     return count;
-                }
-                catch (e) {
-                    try {
-                        db.exec("ROLLBACK");
-                    }
-                    catch { /* no active transaction */ }
-                    throw e;
-                }
+                });
             });
         }),
         exportAttempts: (path) => Effect.gen(function* () {
@@ -1063,23 +1387,14 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const existingHashes = new Set(existing.map(a => contentHash(a.taskId, a.approach)));
             const insertStmt = db.prepare("INSERT INTO attempts (task_id, approach, outcome, reason, created_at) VALUES (?, ?, ?, ?, ?)");
             return yield* importEntityJsonl(filePath, AttemptUpsertOpSchema, existingHashes, (ops) => {
-                db.exec("BEGIN IMMEDIATE");
-                try {
+                return withWriteTransaction(() => {
                     let count = 0;
                     for (const op of ops) {
                         insertStmt.run(op.data.taskId, op.data.approach, op.data.outcome, op.data.reason, op.ts);
                         count++;
                     }
-                    db.exec("COMMIT");
                     return count;
-                }
-                catch (e) {
-                    try {
-                        db.exec("ROLLBACK");
-                    }
-                    catch { /* no active transaction */ }
-                    throw e;
-                }
+                });
             });
         }),
         exportPins: (path) => Effect.gen(function* () {
@@ -1101,65 +1416,18 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                content = excluded.content,
                updated_at = excluded.updated_at`);
             const result = yield* importEntityJsonl(filePath, PinUpsertOpSchema, existingHashes, (ops) => {
-                db.exec("BEGIN IMMEDIATE");
-                try {
+                return withWriteTransaction(() => {
                     let count = 0;
                     for (const op of ops) {
                         upsertStmt.run(op.id, op.data.content, op.ts, op.ts);
                         count++;
                     }
-                    db.exec("COMMIT");
                     return count;
-                }
-                catch (e) {
-                    try {
-                        db.exec("ROLLBACK");
-                    }
-                    catch { /* no active transaction */ }
-                    throw e;
-                }
-            });
-            // Sync imported pins to target files (pins exist to be written to context files)
-            if (result.imported > 0) {
-                const allPins = yield* pinRepo.findAll();
-                const targetFiles = yield* pinRepo.getTargetFiles();
-                const pinMap = new Map();
-                for (const pin of allPins) {
-                    pinMap.set(pin.id, pin.content);
-                }
-                yield* Effect.try({
-                    try: () => {
-                        for (const targetFile of targetFiles) {
-                            const projectRoot = process.cwd();
-                            const resolvedPath = resolve(projectRoot, targetFile);
-                            if (!resolvedPath.startsWith(projectRoot + sep))
-                                continue;
-                            let fileContent = "";
-                            try {
-                                fileContent = readFileSync(resolvedPath, "utf-8");
-                            }
-                            catch { /* file doesn't exist yet */ }
-                            const updated = syncBlocks(fileContent, pinMap);
-                            if (updated !== fileContent) {
-                                const dir = dirname(resolvedPath);
-                                mkdirSync(dir, { recursive: true });
-                                const tempPath = `${resolvedPath}.tmp.${Date.now()}.${process.pid}`;
-                                try {
-                                    writeFileSync(tempPath, updated, "utf-8");
-                                    renameSync(tempPath, resolvedPath);
-                                }
-                                catch (e) {
-                                    try {
-                                        unlinkSync(tempPath);
-                                    }
-                                    catch { /* ignore cleanup error */ }
-                                    throw e;
-                                }
-                            }
-                        }
-                    },
-                    catch: (cause) => new DatabaseError({ cause })
                 });
+            });
+            // Avoid blocking DB transactions with filesystem writes.
+            if (result.imported > 0 && !db.inTransaction) {
+                yield* syncPinsToTargetFiles();
             }
             return result;
         }),
@@ -1202,8 +1470,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
             let orphanedCount = 0;
             const result = yield* importEntityJsonl(filePath, AnchorUpsertOpSchema, existingHashes, (ops) => {
-                db.exec("BEGIN IMMEDIATE");
-                try {
+                return withWriteTransaction(() => {
                     let count = 0;
                     for (const op of ops) {
                         const learningId = hashToLearningId.get(op.data.learningContentHash);
@@ -1214,16 +1481,8 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                         insertStmt.run(learningId, op.data.anchorType, op.data.anchorValue, op.data.filePath, op.data.symbolFqname, op.data.lineStart, op.data.lineEnd, op.data.contentHash, op.data.contentPreview, op.data.status, op.data.pinned ? 1 : 0, op.ts);
                         count++;
                     }
-                    db.exec("COMMIT");
                     return count;
-                }
-                catch (e) {
-                    try {
-                        db.exec("ROLLBACK");
-                    }
-                    catch { /* no active transaction */ }
-                    throw e;
-                }
+                });
             });
             return { imported: result.imported, skipped: result.skipped + orphanedCount };
         }),
@@ -1246,23 +1505,14 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
               (edge_type, source_type, source_id, target_type, target_id, weight, metadata, created_at)
              VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
             return yield* importEntityJsonl(filePath, EdgeUpsertOpSchema, existingHashes, (ops) => {
-                db.exec("BEGIN IMMEDIATE");
-                try {
+                return withWriteTransaction(() => {
                     let count = 0;
                     for (const op of ops) {
                         insertStmt.run(op.data.edgeType, op.data.sourceType, op.data.sourceId, op.data.targetType, op.data.targetId, op.data.weight, JSON.stringify(op.data.metadata), op.ts);
                         count++;
                     }
-                    db.exec("COMMIT");
                     return count;
-                }
-                catch (e) {
-                    try {
-                        db.exec("ROLLBACK");
-                    }
-                    catch { /* no active transaction */ }
-                    throw e;
-                }
+                });
             });
         }),
         exportDocs: (path) => Effect.gen(function* () {
@@ -1304,10 +1554,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const importDocsFileExists = yield* fileExists(filePath);
             if (!importDocsFileExists)
                 return EMPTY_ENTITY_IMPORT_RESULT;
-            const content = yield* Effect.tryPromise({
-                try: () => readFile(filePath, "utf-8"),
-                catch: (cause) => new DatabaseError({ cause })
-            });
+            const content = yield* readUtf8FileWithLimit(filePath);
             const lines = content.trim().split("\n").filter(Boolean);
             if (lines.length === 0)
                 return EMPTY_ENTITY_IMPORT_RESULT;
@@ -1378,8 +1625,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const updateParentDocStmt = db.prepare("UPDATE docs SET parent_doc_id = ? WHERE id = ?");
             return yield* Effect.try({
                 try: () => {
-                    db.exec("BEGIN IMMEDIATE");
-                    try {
+                    return withWriteTransaction(() => {
                         let imported = 0;
                         let skipped = 0;
                         // 1. Import docs (dedup by content hash = kind:name:version)
@@ -1496,16 +1742,8 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                             insertInvariantStmt.run(op.id, op.data.rule, op.data.enforcement, docId, op.data.subsystem, op.data.testRef, op.data.lintRule, op.data.promptRef, op.data.status, op.ts, JSON.stringify(op.data.metadata));
                             imported++;
                         }
-                        db.exec("COMMIT");
                         return { imported, skipped };
-                    }
-                    catch (e) {
-                        try {
-                            db.exec("ROLLBACK");
-                        }
-                        catch { /* no active transaction */ }
-                        throw e;
-                    }
+                    });
                 },
                 catch: (cause) => new DatabaseError({ cause })
             });
@@ -1541,10 +1779,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const importLabelsFileExists = yield* fileExists(filePath);
             if (!importLabelsFileExists)
                 return EMPTY_ENTITY_IMPORT_RESULT;
-            const content = yield* Effect.tryPromise({
-                try: () => readFile(filePath, "utf-8"),
-                catch: (cause) => new DatabaseError({ cause })
-            });
+            const content = yield* readUtf8FileWithLimit(filePath);
             const lines = content.trim().split("\n").filter(Boolean);
             if (lines.length === 0)
                 return EMPTY_ENTITY_IMPORT_RESULT;
@@ -1581,8 +1816,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             const insertAssignmentStmt = db.prepare("INSERT INTO task_label_assignments (task_id, label_id, created_at) VALUES (?, ?, ?)");
             return yield* Effect.try({
                 try: () => {
-                    db.exec("BEGIN IMMEDIATE");
-                    try {
+                    return withWriteTransaction(() => {
                         let imported = 0;
                         let skipped = 0;
                         const newLabelNameToId = new Map();
@@ -1634,80 +1868,301 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                                 skipped++;
                             }
                         }
-                        db.exec("COMMIT");
                         return { imported, skipped };
+                    });
+                },
+                catch: (cause) => new DatabaseError({ cause })
+            });
+        }),
+        export: (path) => Effect.gen(function* () {
+            if (typeof path === "string") {
+                const filePath = resolve(path ?? DEFAULT_JSONL_PATH);
+                const ops = yield* collectLegacyTaskOpsForSync();
+                const jsonl = ops.map(op => JSON.stringify(op)).join("\n");
+                yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+                yield* setConfig("last_export", new Date().toISOString());
+                return {
+                    opCount: ops.length,
+                    path: filePath,
+                };
+            }
+            const ops = yield* collectCurrentOpsForSync();
+            const stream = yield* streamService.getInfo();
+            const day = new Date().toISOString().slice(0, 10);
+            const eventPath = resolve(stream.eventsDir, `events-${day}.jsonl`);
+            if (ops.length === 0) {
+                yield* setConfig("last_export", new Date().toISOString());
+                return { eventCount: 0, streamId: stream.streamId, path: eventPath };
+            }
+            const reservation = yield* streamService.reserveSeq(ops.length);
+            const events = [];
+            let seq = reservation.startSeq;
+            for (const op of ops) {
+                const event = toSyncEvent(op, stream.streamId, seq);
+                if (!event)
+                    continue;
+                events.push(event);
+                seq++;
+            }
+            if (events.length === 0) {
+                yield* setConfig("last_export", new Date().toISOString());
+                return { eventCount: 0, streamId: stream.streamId, path: eventPath };
+            }
+            yield* Effect.tryPromise({
+                try: () => appendFile(eventPath, `${events.map(e => JSON.stringify(e)).join("\n")}\n`, "utf-8"),
+                catch: (cause) => new DatabaseError({ cause })
+            });
+            yield* Effect.try({
+                try: () => {
+                    const insertStmt = db.prepare(`INSERT OR IGNORE INTO sync_events (event_id, stream_id, seq, ts, type, entity_id, v, payload)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+                    withWriteTransaction(() => {
+                        for (const event of events) {
+                            insertStmt.run(event.event_id, event.stream_id, event.seq, event.ts, event.type, event.entity_id, event.v, JSON.stringify(event.payload));
+                        }
+                    });
+                },
+                catch: (cause) => new DatabaseError({ cause })
+            });
+            const lastEvent = events[events.length - 1];
+            yield* streamService.touchStream(stream.streamId, lastEvent.seq, lastEvent.ts);
+            yield* setConfig("last_export", new Date().toISOString());
+            return {
+                eventCount: events.length,
+                streamId: stream.streamId,
+                path: eventPath,
+            };
+        }),
+        import: (path) => Effect.gen(function* () {
+            if (typeof path === "string") {
+                return yield* syncService.importTaskOps(path);
+            }
+            const loaded = yield* loadEventsFromStreams("incremental");
+            if (loaded.events.length === 0) {
+                return { importedEvents: 0, appliedEvents: 0, streamCount: loaded.streamCount };
+            }
+            const buckets = bucketEventsToV1Ops(loaded.events);
+            const tempFiles = yield* writeBucketsToTempFiles(buckets);
+            let shouldSyncPinsToTargets = false;
+            yield* Effect.acquireUseRelease(Effect.try({
+                try: () => db.exec("BEGIN"),
+                catch: (cause) => new DatabaseError({ cause })
+            }), () => Effect.gen(function* () {
+                if (buckets.tasks.length > 0)
+                    yield* syncService.importTaskOps(tempFiles.tasksPath);
+                if (buckets.learnings.length > 0)
+                    yield* syncService.importLearnings(tempFiles.learningsPath);
+                if (buckets.fileLearnings.length > 0)
+                    yield* syncService.importFileLearnings(tempFiles.fileLearningsPath);
+                if (buckets.attempts.length > 0)
+                    yield* syncService.importAttempts(tempFiles.attemptsPath);
+                if (buckets.pins.length > 0) {
+                    const pinImportResult = yield* syncService.importPins(tempFiles.pinsPath);
+                    shouldSyncPinsToTargets = shouldSyncPinsToTargets || pinImportResult.imported > 0;
+                }
+                if (buckets.anchors.length > 0)
+                    yield* syncService.importAnchors(tempFiles.anchorsPath);
+                if (buckets.edges.length > 0)
+                    yield* syncService.importEdges(tempFiles.edgesPath);
+                if (buckets.docs.length > 0)
+                    yield* syncService.importDocs(tempFiles.docsPath);
+                if (buckets.labels.length > 0)
+                    yield* syncService.importLabels(tempFiles.labelsPath);
+                const insertStmt = db.prepare(`INSERT OR IGNORE INTO sync_events (event_id, stream_id, seq, ts, type, entity_id, v, payload, imported_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`);
+                yield* Effect.try({
+                    try: () => {
+                        for (const event of loaded.events) {
+                            insertStmt.run(event.event_id, event.stream_id, event.seq, event.ts, event.type, event.entity_id, event.v, JSON.stringify(event.payload));
+                        }
+                    },
+                    catch: (cause) => new DatabaseError({ cause })
+                });
+                yield* Effect.try({
+                    try: () => {
+                        const lastEventAtByStream = new Map();
+                        for (const event of loaded.events) {
+                            lastEventAtByStream.set(event.stream_id, event.ts);
+                        }
+                        for (const [streamId, maxSeq] of loaded.maxSeqByStream) {
+                            touchStreamProgress(streamId, maxSeq, lastEventAtByStream.get(streamId) ?? null);
+                        }
+                    },
+                    catch: (cause) => new DatabaseError({ cause })
+                });
+                yield* setWatermark(DEFAULT_SYNC_WATERMARK_KEY, new Date().toISOString());
+                yield* setConfig("last_import", new Date().toISOString());
+            }), (_acquire, exit) => Effect.sync(() => {
+                if (Exit.isSuccess(exit)) {
+                    try {
+                        db.exec("COMMIT");
                     }
-                    catch (e) {
+                    catch {
                         try {
                             db.exec("ROLLBACK");
                         }
-                        catch { /* no active transaction */ }
-                        throw e;
+                        catch { /* ignore */ }
                     }
-                },
+                }
+                else {
+                    try {
+                        db.exec("ROLLBACK");
+                    }
+                    catch { /* ignore */ }
+                }
+            })).pipe(Effect.ensuring(cleanupTempDir(tempFiles.dir)));
+            if (shouldSyncPinsToTargets) {
+                yield* syncPinsToTargetFiles();
+            }
+            return {
+                importedEvents: loaded.events.length,
+                appliedEvents: loaded.events.length,
+                streamCount: loaded.streamCount,
+            };
+        }),
+        hydrate: () => Effect.gen(function* () {
+            const loaded = yield* loadEventsFromStreams("all");
+            if (loaded.events.length === 0) {
+                return { importedEvents: 0, appliedEvents: 0, streamCount: loaded.streamCount, rebuilt: true };
+            }
+            const buckets = bucketEventsToV1Ops(loaded.events);
+            const tempFiles = yield* writeBucketsToTempFiles(buckets);
+            let shouldSyncPinsToTargets = false;
+            yield* Effect.acquireUseRelease(Effect.try({
+                try: () => db.exec("BEGIN"),
                 catch: (cause) => new DatabaseError({ cause })
-            });
+            }), () => Effect.gen(function* () {
+                const insertStmt = db.prepare(`INSERT OR IGNORE INTO sync_events (event_id, stream_id, seq, ts, type, entity_id, v, payload, imported_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`);
+                yield* Effect.try({
+                    try: () => {
+                        for (const event of loaded.events) {
+                            insertStmt.run(event.event_id, event.stream_id, event.seq, event.ts, event.type, event.entity_id, event.v, JSON.stringify(event.payload));
+                        }
+                    },
+                    catch: (cause) => new DatabaseError({ cause })
+                });
+                yield* clearMaterializedTables();
+                if (buckets.tasks.length > 0)
+                    yield* syncService.importTaskOps(tempFiles.tasksPath);
+                if (buckets.learnings.length > 0)
+                    yield* syncService.importLearnings(tempFiles.learningsPath);
+                if (buckets.fileLearnings.length > 0)
+                    yield* syncService.importFileLearnings(tempFiles.fileLearningsPath);
+                if (buckets.attempts.length > 0)
+                    yield* syncService.importAttempts(tempFiles.attemptsPath);
+                if (buckets.pins.length > 0) {
+                    const pinImportResult = yield* syncService.importPins(tempFiles.pinsPath);
+                    shouldSyncPinsToTargets = shouldSyncPinsToTargets || pinImportResult.imported > 0;
+                }
+                if (buckets.anchors.length > 0)
+                    yield* syncService.importAnchors(tempFiles.anchorsPath);
+                if (buckets.edges.length > 0)
+                    yield* syncService.importEdges(tempFiles.edgesPath);
+                if (buckets.docs.length > 0)
+                    yield* syncService.importDocs(tempFiles.docsPath);
+                if (buckets.labels.length > 0)
+                    yield* syncService.importLabels(tempFiles.labelsPath);
+                yield* Effect.try({
+                    try: () => {
+                        const lastEventAtByStream = new Map();
+                        for (const event of loaded.events) {
+                            lastEventAtByStream.set(event.stream_id, event.ts);
+                        }
+                        for (const [streamId, maxSeq] of loaded.maxSeqByStream) {
+                            touchStreamProgress(streamId, maxSeq, lastEventAtByStream.get(streamId) ?? null);
+                        }
+                    },
+                    catch: (cause) => new DatabaseError({ cause })
+                });
+                yield* setWatermark(DEFAULT_SYNC_WATERMARK_KEY, new Date().toISOString());
+                yield* setConfig("last_import", new Date().toISOString());
+            }), (_acquire, exit) => Effect.sync(() => {
+                if (Exit.isSuccess(exit)) {
+                    try {
+                        db.exec("COMMIT");
+                    }
+                    catch {
+                        try {
+                            db.exec("ROLLBACK");
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
+                else {
+                    try {
+                        db.exec("ROLLBACK");
+                    }
+                    catch { /* ignore */ }
+                }
+            })).pipe(Effect.ensuring(cleanupTempDir(tempFiles.dir)));
+            if (shouldSyncPinsToTargets) {
+                yield* syncPinsToTargetFiles();
+            }
+            return {
+                importedEvents: loaded.events.length,
+                appliedEvents: loaded.events.length,
+                streamCount: loaded.streamCount,
+                rebuilt: true
+            };
         }),
-        exportAll: (options) => Effect.gen(function* () {
-            const tasks = yield* syncService.export();
-            const learnings = options?.learnings !== false
-                ? yield* syncService.exportLearnings()
-                : undefined;
-            const fileLearnings = options?.fileLearnings !== false
-                ? yield* syncService.exportFileLearnings()
-                : undefined;
-            const attempts = options?.attempts !== false
-                ? yield* syncService.exportAttempts()
-                : undefined;
-            const pins = options?.pins !== false
-                ? yield* syncService.exportPins()
-                : undefined;
-            const anchors = options?.anchors !== false
-                ? yield* syncService.exportAnchors()
-                : undefined;
-            const edges = options?.edges !== false
-                ? yield* syncService.exportEdges()
-                : undefined;
-            const docs = options?.docs !== false
-                ? yield* syncService.exportDocs()
-                : undefined;
-            const labels = options?.labels !== false
-                ? yield* syncService.exportLabels()
-                : undefined;
-            return { tasks, learnings, fileLearnings, attempts, pins, anchors, edges, docs, labels };
+        compact: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_JSONL_PATH);
+            const records = yield* readJsonlRecords(filePath);
+            if (records.length === 0) {
+                return { before: 0, after: 0, path: filePath };
+            }
+            const before = records.length;
+            const taskStates = new Map();
+            const depStates = new Map();
+            for (const record of records) {
+                const op = yield* Effect.try({
+                    try: () => Schema.decodeUnknownSync(TaskSyncOperationSchema)(record),
+                    catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
+                });
+                if (op.op === "upsert" || op.op === "delete") {
+                    const existing = taskStates.get(op.id);
+                    if (!existing || compareSyncOrder(op, existing) > 0) {
+                        taskStates.set(op.id, { op: op, ts: op.ts, eventId: op.eventId });
+                    }
+                }
+                else if (op.op === "dep_add" || op.op === "dep_remove") {
+                    const key = `${op.blockerId}:${op.blockedId}`;
+                    const existing = depStates.get(key);
+                    if (!existing || compareSyncOrder(op, existing) > 0) {
+                        depStates.set(key, { op: op, ts: op.ts, eventId: op.eventId });
+                    }
+                }
+            }
+            const compacted = [];
+            for (const state of taskStates.values()) {
+                if (state.op.op === "upsert") {
+                    compacted.push(state.op);
+                }
+            }
+            for (const state of depStates.values()) {
+                if (state.op.op === "dep_add") {
+                    compacted.push(state.op);
+                }
+            }
+            compacted.sort(compareOpOrder);
+            const jsonl = compacted.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { before, after: compacted.length, path: filePath };
         }),
-        importAll: (options) => Effect.gen(function* () {
-            // Import in dependency order: tasks → learnings → anchors → edges → file-learnings → attempts → pins → docs → labels
-            const tasks = yield* syncService.import();
-            const learnings = options?.learnings !== false
-                ? yield* syncService.importLearnings()
-                : undefined;
-            // Anchors depend on learnings (FK reference) — skip if learnings are disabled
-            const anchors = options?.anchors !== false && options?.learnings !== false
-                ? yield* syncService.importAnchors()
-                : undefined;
-            // Edges are a generic graph layer with no FK dependency on learnings
-            const edges = options?.edges !== false
-                ? yield* syncService.importEdges()
-                : undefined;
-            const fileLearnings = options?.fileLearnings !== false
-                ? yield* syncService.importFileLearnings()
-                : undefined;
-            const attempts = options?.attempts !== false
-                ? yield* syncService.importAttempts()
-                : undefined;
-            const pins = options?.pins !== false
-                ? yield* syncService.importPins()
-                : undefined;
-            const docs = options?.docs !== false
-                ? yield* syncService.importDocs()
-                : undefined;
-            const labels = options?.labels !== false
-                ? yield* syncService.importLabels()
-                : undefined;
-            return { tasks, learnings, fileLearnings, attempts, pins, anchors, edges, docs, labels };
+        stream: () => Effect.gen(function* () {
+            const info = yield* streamService.getInfo();
+            const knownStreams = yield* streamService.listProgress();
+            return {
+                streamId: info.streamId,
+                nextSeq: info.nextSeq,
+                lastSeq: info.lastSeq,
+                eventsDir: info.eventsDir,
+                configPath: info.configPath,
+                knownStreams
+            };
         })
-    };
+    }));
     return syncService;
 }));
-//# sourceMappingURL=sync-service.js.map
+//# sourceMappingURL=service-impl.js.map