@jamesaphoenix/tx-core 0.5.10 → 0.6.0

package/dist/services/sync-service.js

@@ -1,13 +1,21 @@
 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 { readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
-import { dirname, resolve } from "node:path";
+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 { SyncOperation as SyncOperationSchema } from "../schemas/sync.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";
 /**
  * SyncService provides JSONL-based export/import for git-tracked task syncing.
  * See DD-009 for full specification.
@@ -15,6 +23,32 @@ import { SyncOperation as SyncOperationSchema } from "../schemas/sync.js";
 export class SyncService extends Context.Tag("SyncService")() {
 }
 const DEFAULT_JSONL_PATH = ".tx/tasks.jsonl";
+const DEFAULT_LEARNINGS_JSONL_PATH = ".tx/learnings.jsonl";
+const DEFAULT_FILE_LEARNINGS_JSONL_PATH = ".tx/file-learnings.jsonl";
+const DEFAULT_ATTEMPTS_JSONL_PATH = ".tx/attempts.jsonl";
+const DEFAULT_PINS_JSONL_PATH = ".tx/pins.jsonl";
+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";
+/**
+ * Compute a content hash for cross-machine dedup.
+ * Entities with auto-increment IDs use this to identify duplicates.
+ */
+const contentHash = (...parts) => createHash("sha256").update(parts.join("|")).digest("hex");
+/**
+ * Convert SQLite datetime string ("YYYY-MM-DD HH:MM:SS") to ISO 8601 ("YYYY-MM-DDTHH:MM:SS").
+ * Labels use raw SQL so timestamps come in SQLite format rather than Date objects.
+ */
+const sqliteToIso = (s) => {
+    if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(s))
+        return s.replace(" ", "T") + ".000Z";
+    return s;
+};
+/**
+ * Empty entity import result for early returns.
+ */
+const EMPTY_ENTITY_IMPORT_RESULT = { imported: 0, skipped: 0 };
 /**
  * Empty import result for early returns.
  */
@@ -115,6 +149,8 @@ const taskToUpsertOp = (task) => ({
         status: task.status,
         score: task.score,
         parentId: task.parentId,
+        createdAt: task.createdAt.toISOString(),
+        completedAt: task.completedAt?.toISOString() ?? null,
         assigneeType: task.assigneeType ?? null,
         assigneeId: task.assigneeId ?? null,
         assignedAt: task.assignedAt?.toISOString() ?? null,
@@ -132,6 +168,294 @@ const depToAddOp = (dep) => ({
     blockerId: dep.blockerId,
     blockedId: dep.blockedId
 });
+/**
+ * Convert a Learning to a LearningUpsertOp for JSONL export.
+ */
+const learningToUpsertOp = (learning) => ({
+    v: 1,
+    op: "learning_upsert",
+    ts: learning.createdAt.toISOString(),
+    id: learning.id,
+    contentHash: contentHash(learning.content, learning.sourceType),
+    data: {
+        content: learning.content,
+        sourceType: learning.sourceType,
+        sourceRef: learning.sourceRef,
+        keywords: [...learning.keywords],
+        category: learning.category
+    }
+});
+/**
+ * Convert a FileLearning to a FileLearningUpsertOp for JSONL export.
+ */
+const fileLearningToUpsertOp = (fl) => ({
+    v: 1,
+    op: "file_learning_upsert",
+    ts: fl.createdAt.toISOString(),
+    id: fl.id,
+    contentHash: contentHash(fl.filePattern, fl.note),
+    data: {
+        filePattern: fl.filePattern,
+        note: fl.note,
+        taskId: fl.taskId
+    }
+});
+/**
+ * Convert an Attempt to an AttemptUpsertOp for JSONL export.
+ */
+const attemptToUpsertOp = (attempt) => ({
+    v: 1,
+    op: "attempt_upsert",
+    ts: attempt.createdAt.toISOString(),
+    id: attempt.id,
+    contentHash: contentHash(attempt.taskId, attempt.approach),
+    data: {
+        taskId: attempt.taskId,
+        approach: attempt.approach,
+        outcome: attempt.outcome,
+        reason: attempt.reason
+    }
+});
+/**
+ * Convert a Pin to a PinUpsertOp for JSONL export.
+ */
+const pinToUpsertOp = (pin) => ({
+    v: 1,
+    op: "pin_upsert",
+    ts: new Date(pin.updatedAt).toISOString(),
+    id: pin.id,
+    contentHash: contentHash(pin.id, pin.content),
+    data: {
+        content: pin.content
+    }
+});
+/**
+ * Convert an Anchor to an AnchorUpsertOp for JSONL export.
+ * Uses the learning's content hash (looked up from learningHashMap) as stable reference.
+ */
+const anchorToUpsertOp = (anchor, learningHashMap) => {
+    const learningContentHash = learningHashMap.get(anchor.learningId) ?? "";
+    return {
+        v: 1,
+        op: "anchor_upsert",
+        ts: anchor.createdAt.toISOString(),
+        id: anchor.id,
+        contentHash: contentHash(learningContentHash, anchor.filePath, anchor.anchorType, anchor.anchorValue),
+        data: {
+            learningContentHash,
+            anchorType: anchor.anchorType,
+            anchorValue: anchor.anchorValue,
+            filePath: anchor.filePath,
+            symbolFqname: anchor.symbolFqname,
+            lineStart: anchor.lineStart,
+            lineEnd: anchor.lineEnd,
+            contentHash: anchor.contentHash,
+            contentPreview: anchor.contentPreview,
+            status: anchor.status,
+            pinned: anchor.pinned
+        }
+    };
+};
+/**
+ * Convert an Edge to an EdgeUpsertOp for JSONL export.
+ */
+const edgeToUpsertOp = (edge) => ({
+    v: 1,
+    op: "edge_upsert",
+    ts: edge.createdAt.toISOString(),
+    id: edge.id,
+    contentHash: contentHash(edge.edgeType, edge.sourceType, edge.sourceId, edge.targetType, edge.targetId),
+    data: {
+        edgeType: edge.edgeType,
+        sourceType: edge.sourceType,
+        sourceId: edge.sourceId,
+        targetType: edge.targetType,
+        targetId: edge.targetId,
+        weight: edge.weight,
+        metadata: edge.metadata
+    }
+});
+/**
+ * Convert a Doc to a DocUpsertOp for JSONL export.
+ */
+const docToUpsertOp = (doc, parentDocKeyMap) => ({
+    v: 1,
+    op: "doc_upsert",
+    ts: doc.createdAt.toISOString(),
+    id: doc.id,
+    contentHash: contentHash(doc.kind, doc.name, String(doc.version)),
+    data: {
+        kind: doc.kind,
+        name: doc.name,
+        title: doc.title,
+        version: doc.version,
+        status: doc.status,
+        filePath: doc.filePath,
+        hash: doc.hash,
+        parentDocKey: doc.parentDocId ? (parentDocKeyMap.get(doc.parentDocId) ?? null) : null,
+        lockedAt: doc.lockedAt?.toISOString() ?? null,
+        metadata: doc.metadata
+    }
+});
+/**
+ * Convert a DocLink to a DocLinkUpsertOp for JSONL export.
+ * Uses docKeyMap to resolve integer IDs to stable name:version keys.
+ */
+const docLinkToUpsertOp = (link, docKeyMap) => {
+    const fromDocKey = docKeyMap.get(link.fromDocId);
+    const toDocKey = docKeyMap.get(link.toDocId);
+    if (!fromDocKey || !toDocKey)
+        return null;
+    return {
+        v: 1,
+        op: "doc_link_upsert",
+        ts: link.createdAt.toISOString(),
+        id: link.id,
+        contentHash: contentHash(fromDocKey, toDocKey, link.linkType),
+        data: {
+            fromDocKey,
+            toDocKey,
+            linkType: link.linkType
+        }
+    };
+};
+/**
+ * Convert a TaskDocLink to a TaskDocLinkUpsertOp for JSONL export.
+ * Uses docKeyMap to resolve integer doc IDs to stable name:version keys.
+ */
+const taskDocLinkToUpsertOp = (link, docKeyMap) => {
+    const docKey = docKeyMap.get(link.docId);
+    if (!docKey)
+        return null;
+    return {
+        v: 1,
+        op: "task_doc_link_upsert",
+        ts: link.createdAt.toISOString(),
+        id: link.id,
+        contentHash: contentHash(link.taskId, docKey),
+        data: {
+            taskId: link.taskId,
+            docKey,
+            linkType: link.linkType
+        }
+    };
+};
+/**
+ * Convert an Invariant to an InvariantUpsertOp for JSONL export.
+ * Uses docKeyMap to resolve integer doc IDs to stable name:version keys.
+ */
+const invariantToUpsertOp = (inv, docKeyMap) => {
+    const docKey = docKeyMap.get(inv.docId);
+    if (!docKey)
+        return null;
+    return {
+        v: 1,
+        op: "invariant_upsert",
+        ts: inv.createdAt.toISOString(),
+        id: inv.id,
+        contentHash: contentHash(inv.id),
+        data: {
+            id: inv.id,
+            rule: inv.rule,
+            enforcement: inv.enforcement,
+            docKey,
+            subsystem: inv.subsystem,
+            testRef: inv.testRef,
+            lintRule: inv.lintRule,
+            promptRef: inv.promptRef,
+            status: inv.status,
+            metadata: inv.metadata
+        }
+    };
+};
+/**
+ * Convert a label row to a LabelUpsertOp for JSONL export.
+ */
+const labelRowToUpsertOp = (row) => ({
+    v: 1,
+    op: "label_upsert",
+    ts: sqliteToIso(row.updated_at),
+    id: row.id,
+    contentHash: contentHash(row.name.toLowerCase()),
+    data: {
+        name: row.name,
+        color: row.color
+    }
+});
+/**
+ * Convert a label assignment row to a LabelAssignmentUpsertOp for JSONL export.
+ * Uses labelNameMap to resolve integer label IDs to stable names.
+ */
+const labelAssignmentToUpsertOp = (row, labelNameMap) => {
+    const labelName = labelNameMap.get(row.label_id);
+    if (!labelName)
+        return null;
+    return {
+        v: 1,
+        op: "label_assignment_upsert",
+        ts: sqliteToIso(row.created_at),
+        contentHash: contentHash(row.task_id, labelName.toLowerCase()),
+        data: {
+            taskId: row.task_id,
+            labelName
+        }
+    };
+};
+/**
+ * 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.
+ */
+const importEntityJsonl = (filePath, schema, existingHashes, insertBatch) => Effect.gen(function* () {
+    const importFileExists = yield* fileExists(filePath);
+    if (!importFileExists) {
+        return EMPTY_ENTITY_IMPORT_RESULT;
+    }
+    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);
+        }
+    }
+    // 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 };
+});
 /**
  * Check if a file exists without blocking the event loop.
  */
@@ -154,6 +478,13 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
     const taskService = yield* TaskService;
     const depRepo = yield* DependencyRepository;
     const db = yield* SqliteClient;
+    const learningRepo = yield* LearningRepository;
+    const fileLearningRepo = yield* FileLearningRepository;
+    const attemptRepo = yield* AttemptRepository;
+    const pinRepo = yield* PinRepository;
+    const anchorRepo = yield* AnchorRepository;
+    const edgeRepo = yield* EdgeRepository;
+    const docRepo = yield* DocRepository;
     // Helper: Get config value from sync_config table
     const getConfig = (key) => Effect.try({
         try: () => {
@@ -169,7 +500,7 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
         },
         catch: (cause) => new DatabaseError({ cause })
     });
-    return {
+    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)
@@ -257,6 +588,14 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             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 = ?");
+            // Cycle detection: check if adding blocker_id→blocked_id would create a cycle
+            // by walking DOWNSTREAM from blocked_id to see if it can reach blocker_id
+            const checkCycleStmt = db.prepare(`WITH RECURSIVE reachable(id) AS (
+              SELECT blocked_id FROM task_dependencies WHERE blocker_id = ?
+              UNION
+              SELECT d.blocked_id FROM task_dependencies d JOIN reachable r ON d.blocker_id = r.id
+            )
+            SELECT 1 AS found FROM reachable WHERE id = ? LIMIT 1`);
             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 = ?");
@@ -297,15 +636,14 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                             const assignedBy = assigneeType === null ? null : (op.data.assignedBy ?? 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, assigneeType, assigneeId, assignedAt, assignedBy, JSON.stringify(op.data.metadata));
+                                insertTaskStmt.run(id, op.data.title, op.data.description, op.data.status, effectiveParentId, op.data.score, op.data.createdAt ?? op.ts, op.ts, op.data.completedAt ?? null, assigneeType, assigneeId, assignedAt, assignedBy, 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, assigneeType, assigneeId, assignedAt, assignedBy, JSON.stringify(op.data.metadata), id);
+                                    updateTaskStmt.run(op.data.title, op.data.description, op.data.status, effectiveParentId, op.data.score, op.ts, op.data.completedAt !== undefined ? op.data.completedAt : (existingRow.completed_at ?? null), assigneeType, assigneeId, assignedAt, assignedBy, JSON.stringify(op.data.metadata), id);
                                     imported++;
                                 }
                                 else if (op.ts === existingTs) {
@@ -348,13 +686,23 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
                                 depsSkipped++;
                                 continue;
                             }
+                            // Check for cycles before inserting (RULE 4: no circular deps)
+                            const wouldCycle = checkCycleStmt.get(op.blockedId, op.blockerId);
+                            if (wouldCycle) {
+                                depFailures.push({
+                                    blockerId: op.blockerId,
+                                    blockedId: op.blockedId,
+                                    error: "would create circular dependency"
+                                });
+                                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)
+                                // Dependency insert failed (e.g., foreign key constraint)
                                 depFailures.push({
                                     blockerId: op.blockerId,
                                     blockedId: op.blockedId,
@@ -411,10 +759,22 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             // Release: Commit on success, rollback on failure
             (_, exit) => Effect.sync(() => {
                 if (Exit.isSuccess(exit)) {
-                    db.exec("COMMIT");
+                    try {
+                        db.exec("COMMIT");
+                    }
+                    catch {
+                        // COMMIT failed — roll back to prevent a stuck open transaction
+                        try {
+                            db.exec("ROLLBACK");
+                        }
+                        catch { /* already rolled back */ }
+                    }
                 }
                 else {
-                    db.exec("ROLLBACK");
+                    try {
+                        db.exec("ROLLBACK");
+                    }
+                    catch { /* no active transaction */ }
                 }
             }));
         }),
@@ -619,7 +979,735 @@ export const SyncServiceLive = Layer.effect(SyncService, Effect.gen(function* ()
             return { before, after: compacted.length };
         }),
         setLastExport: (timestamp) => setConfig("last_export", timestamp.toISOString()),
-        setLastImport: (timestamp) => setConfig("last_import", 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();
+            const ops = learnings.map(learningToUpsertOp);
+            ops.sort((a, b) => a.ts.localeCompare(b.ts));
+            const jsonl = ops.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { opCount: ops.length, path: filePath };
+        }),
+        importLearnings: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_LEARNINGS_JSONL_PATH);
+            const existing = yield* learningRepo.findAll();
+            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 {
+                    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* () {
+            const filePath = resolve(path ?? DEFAULT_FILE_LEARNINGS_JSONL_PATH);
+            const fileLearnings = yield* fileLearningRepo.findAll();
+            const ops = fileLearnings.map(fileLearningToUpsertOp);
+            ops.sort((a, b) => a.ts.localeCompare(b.ts));
+            const jsonl = ops.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { opCount: ops.length, path: filePath };
+        }),
+        importFileLearnings: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_FILE_LEARNINGS_JSONL_PATH);
+            const existing = yield* fileLearningRepo.findAll();
+            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 {
+                    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* () {
+            const filePath = resolve(path ?? DEFAULT_ATTEMPTS_JSONL_PATH);
+            const attempts = yield* attemptRepo.findAll();
+            const ops = attempts.map(attemptToUpsertOp);
+            ops.sort((a, b) => a.ts.localeCompare(b.ts));
+            const jsonl = ops.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { opCount: ops.length, path: filePath };
+        }),
+        importAttempts: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_ATTEMPTS_JSONL_PATH);
+            const existing = yield* attemptRepo.findAll();
+            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 {
+                    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* () {
+            const filePath = resolve(path ?? DEFAULT_PINS_JSONL_PATH);
+            const pins = yield* pinRepo.findAll();
+            const ops = [...pins].map(pinToUpsertOp);
+            ops.sort((a, b) => a.ts.localeCompare(b.ts));
+            const jsonl = ops.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { opCount: ops.length, path: filePath };
+        }),
+        importPins: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_PINS_JSONL_PATH);
+            const existing = yield* pinRepo.findAll();
+            const existingHashes = new Set([...existing].map(p => contentHash(p.id, p.content)));
+            const upsertStmt = db.prepare(`INSERT INTO context_pins (id, content, created_at, updated_at)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET
+               content = excluded.content,
+               updated_at = excluded.updated_at`);
+            const result = yield* importEntityJsonl(filePath, PinUpsertOpSchema, existingHashes, (ops) => {
+                db.exec("BEGIN IMMEDIATE");
+                try {
+                    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 })
+                });
+            }
+            return result;
+        }),
+        exportAnchors: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_ANCHORS_JSONL_PATH);
+            const anchors = yield* anchorRepo.findAll();
+            // Build learning ID → content hash map for stable references
+            const learnings = yield* learningRepo.findAll();
+            const learningHashMap = new Map();
+            for (const l of learnings) {
+                learningHashMap.set(l.id, contentHash(l.content, l.sourceType));
+            }
+            const ops = anchors.map(a => anchorToUpsertOp(a, learningHashMap));
+            ops.sort((a, b) => a.ts.localeCompare(b.ts));
+            const jsonl = ops.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { opCount: ops.length, path: filePath };
+        }),
+        importAnchors: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_ANCHORS_JSONL_PATH);
+            // Build existing anchor content hashes
+            const existingAnchors = yield* anchorRepo.findAll();
+            const existingLearnings = yield* learningRepo.findAll();
+            const learningHashMap = new Map();
+            for (const l of existingLearnings) {
+                learningHashMap.set(l.id, contentHash(l.content, l.sourceType));
+            }
+            const existingHashes = new Set(existingAnchors.map(a => {
+                const lHash = learningHashMap.get(a.learningId) ?? "";
+                return contentHash(lHash, a.filePath, a.anchorType, a.anchorValue);
+            }));
+            // Build reverse map: learning content hash → learning ID (for resolving references)
+            const hashToLearningId = new Map();
+            for (const l of existingLearnings) {
+                hashToLearningId.set(contentHash(l.content, l.sourceType), l.id);
+            }
+            const insertStmt = db.prepare(`INSERT INTO learning_anchors
+              (learning_id, anchor_type, anchor_value, file_path, symbol_fqname,
+               line_start, line_end, content_hash, content_preview, status, pinned, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            let orphanedCount = 0;
+            const result = yield* importEntityJsonl(filePath, AnchorUpsertOpSchema, existingHashes, (ops) => {
+                db.exec("BEGIN IMMEDIATE");
+                try {
+                    let count = 0;
+                    for (const op of ops) {
+                        const learningId = hashToLearningId.get(op.data.learningContentHash);
+                        if (learningId === undefined) {
+                            orphanedCount++;
+                            continue;
+                        }
+                        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 };
+        }),
+        exportEdges: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_EDGES_JSONL_PATH);
+            const edges = yield* edgeRepo.findAll();
+            // Only export active (non-invalidated) edges
+            const activeEdges = edges.filter(e => e.invalidatedAt === null);
+            const ops = activeEdges.map(edgeToUpsertOp);
+            ops.sort((a, b) => a.ts.localeCompare(b.ts));
+            const jsonl = ops.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { opCount: ops.length, path: filePath };
+        }),
+        importEdges: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_EDGES_JSONL_PATH);
+            const existingEdges = yield* edgeRepo.findAll();
+            const existingHashes = new Set(existingEdges.map(e => contentHash(e.edgeType, e.sourceType, e.sourceId, e.targetType, e.targetId)));
+            const insertStmt = db.prepare(`INSERT INTO learning_edges
+              (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 {
+                    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* () {
+            const filePath = resolve(path ?? DEFAULT_DOCS_JSONL_PATH);
+            const docs = yield* docRepo.findAll();
+            // Build doc ID → "name:version" key map for stable cross-machine references
+            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));
+            // Get doc links
+            const docLinks = yield* docRepo.getAllLinks();
+            const docLinkOps = docLinks
+                .map(l => docLinkToUpsertOp(l, docKeyMap))
+                .filter((op) => op !== null);
+            // Get task-doc links via raw SQL (no getAllTaskLinks method)
+            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);
+            // Get invariants
+            const invariants = yield* docRepo.findInvariants();
+            const invariantOps = invariants
+                .map(inv => invariantToUpsertOp(inv, docKeyMap))
+                .filter((op) => op !== null);
+            // Combine all ops, sort by timestamp
+            const allOps = [...docOps, ...docLinkOps, ...taskDocLinkOps, ...invariantOps];
+            allOps.sort((a, b) => a.ts.localeCompare(b.ts));
+            const jsonl = allOps.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { opCount: allOps.length, path: filePath };
+        }),
+        importDocs: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_DOCS_JSONL_PATH);
+            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 lines = content.trim().split("\n").filter(Boolean);
+            if (lines.length === 0)
+                return EMPTY_ENTITY_IMPORT_RESULT;
+            // Parse all ops, group by type
+            const docOps = [];
+            const docLinkOps = [];
+            const taskDocLinkOps = [];
+            const invariantOps = [];
+            for (const line of lines) {
+                const parsed = yield* Effect.try({
+                    try: () => JSON.parse(line),
+                    catch: (cause) => new ValidationError({ reason: `Invalid JSON: ${cause}` })
+                });
+                const opType = parsed.op;
+                if (opType === "doc_upsert") {
+                    docOps.push(yield* Effect.try({
+                        try: () => Schema.decodeUnknownSync(DocUpsertOpSchema)(parsed),
+                        catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
+                    }));
+                }
+                else if (opType === "doc_link_upsert") {
+                    docLinkOps.push(yield* Effect.try({
+                        try: () => Schema.decodeUnknownSync(DocLinkUpsertOpSchema)(parsed),
+                        catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
+                    }));
+                }
+                else if (opType === "task_doc_link_upsert") {
+                    taskDocLinkOps.push(yield* Effect.try({
+                        try: () => Schema.decodeUnknownSync(TaskDocLinkUpsertOpSchema)(parsed),
+                        catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
+                    }));
+                }
+                else if (opType === "invariant_upsert") {
+                    invariantOps.push(yield* Effect.try({
+                        try: () => Schema.decodeUnknownSync(InvariantUpsertOpSchema)(parsed),
+                        catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
+                    }));
+                }
+            }
+            // Pre-dedup sub-entity ops by contentHash (keep latest timestamp per hash)
+            const dedupByHash = (ops) => {
+                const map = new Map();
+                for (const op of ops) {
+                    const existing = map.get(op.contentHash);
+                    if (!existing || op.ts > existing.ts)
+                        map.set(op.contentHash, op);
+                }
+                return [...map.values()];
+            };
+            const dedupedDocLinkOps = dedupByHash(docLinkOps);
+            const dedupedTaskDocLinkOps = dedupByHash(taskDocLinkOps);
+            const dedupedInvariantOps = dedupByHash(invariantOps);
+            // Build existing doc hashes for dedup
+            const existingDocs = yield* docRepo.findAll();
+            const existingDocHashes = new Set(existingDocs.map(d => contentHash(d.kind, d.name, String(d.version))));
+            // Prepare statements
+            const insertDocStmt = db.prepare(`INSERT OR IGNORE INTO docs (hash, kind, name, title, version, status, file_path, parent_doc_id, locked_at, created_at, metadata)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            const findDocByNameVersionStmt = db.prepare("SELECT id FROM docs WHERE name = ? AND version = ?");
+            const checkDocLinkStmt = db.prepare("SELECT 1 FROM doc_links WHERE from_doc_id = ? AND to_doc_id = ? AND link_type = ?");
+            const insertDocLinkStmt = db.prepare("INSERT INTO doc_links (from_doc_id, to_doc_id, link_type, created_at) VALUES (?, ?, ?, ?)");
+            const checkTaskDocLinkStmt = db.prepare("SELECT 1 FROM task_doc_links WHERE task_id = ? AND doc_id = ? AND link_type = ?");
+            const insertTaskDocLinkStmt = db.prepare("INSERT INTO task_doc_links (task_id, doc_id, link_type, created_at) VALUES (?, ?, ?, ?)");
+            const findInvariantStmt = db.prepare("SELECT 1 FROM invariants WHERE id = ?");
+            const insertInvariantStmt = db.prepare(`INSERT INTO invariants (id, rule, enforcement, doc_id, subsystem, test_ref, lint_rule, prompt_ref, status, created_at, metadata)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            // Hoist parent resolution UPDATE statement outside the loop
+            const updateParentDocStmt = db.prepare("UPDATE docs SET parent_doc_id = ? WHERE id = ?");
+            return yield* Effect.try({
+                try: () => {
+                    db.exec("BEGIN IMMEDIATE");
+                    try {
+                        let imported = 0;
+                        let skipped = 0;
+                        // 1. Import docs (dedup by content hash = kind:name:version)
+                        // Track newly inserted doc keys for parent resolution
+                        const newDocKeyToId = new Map();
+                        const insertedDocKeys = new Set();
+                        for (const op of docOps) {
+                            if (existingDocHashes.has(op.contentHash)) {
+                                // Still populate the key map for link resolution
+                                const existing = findDocByNameVersionStmt.get(op.data.name, op.data.version);
+                                if (existing)
+                                    newDocKeyToId.set(`${op.data.name}:${op.data.version}`, existing.id);
+                                skipped++;
+                                continue;
+                            }
+                            // Check if doc already exists by name+version (handles kind mismatch with UNIQUE index)
+                            const existing = findDocByNameVersionStmt.get(op.data.name, op.data.version);
+                            if (existing) {
+                                newDocKeyToId.set(`${op.data.name}:${op.data.version}`, existing.id);
+                                skipped++;
+                                continue;
+                            }
+                            // INSERT OR IGNORE handles race with UNIQUE(name, version)
+                            const result = insertDocStmt.run(op.data.hash, op.data.kind, op.data.name, op.data.title, op.data.version, op.data.status, op.data.filePath, null, // parent_doc_id resolved after all docs inserted
+                            op.data.lockedAt ?? null, op.ts, JSON.stringify(op.data.metadata));
+                            if (result.changes > 0) {
+                                const docKey = `${op.data.name}:${op.data.version}`;
+                                newDocKeyToId.set(docKey, result.lastInsertRowid);
+                                insertedDocKeys.add(docKey);
+                                imported++;
+                            }
+                            else {
+                                // INSERT OR IGNORE did nothing — row already exists
+                                const row = findDocByNameVersionStmt.get(op.data.name, op.data.version);
+                                if (row)
+                                    newDocKeyToId.set(`${op.data.name}:${op.data.version}`, row.id);
+                                skipped++;
+                            }
+                        }
+                        // Helper: resolve docKey (name:version) to doc ID
+                        const resolveDocKey = (docKey) => {
+                            const newId = newDocKeyToId.get(docKey);
+                            if (newId !== undefined)
+                                return newId;
+                            const parts = docKey.split(":");
+                            if (parts.length < 2)
+                                return undefined;
+                            const name = parts.slice(0, -1).join(":");
+                            const version = parseInt(parts[parts.length - 1], 10);
+                            if (isNaN(version))
+                                return undefined;
+                            const row = findDocByNameVersionStmt.get(name, version);
+                            return row?.id;
+                        };
+                        // Resolve parent doc references — only for newly inserted docs
+                        for (const op of docOps) {
+                            if (!op.data.parentDocKey)
+                                continue;
+                            const docKey = `${op.data.name}:${op.data.version}`;
+                            if (!insertedDocKeys.has(docKey))
+                                continue;
+                            const docId = resolveDocKey(docKey);
+                            const parentId = resolveDocKey(op.data.parentDocKey);
+                            if (docId && parentId) {
+                                updateParentDocStmt.run(parentId, docId);
+                            }
+                        }
+                        // 2. Import doc links
+                        for (const op of dedupedDocLinkOps) {
+                            const fromId = resolveDocKey(op.data.fromDocKey);
+                            const toId = resolveDocKey(op.data.toDocKey);
+                            if (!fromId || !toId) {
+                                skipped++;
+                                continue;
+                            }
+                            if (checkDocLinkStmt.get(fromId, toId, op.data.linkType)) {
+                                skipped++;
+                                continue;
+                            }
+                            insertDocLinkStmt.run(fromId, toId, op.data.linkType, op.ts);
+                            imported++;
+                        }
+                        // 3. Import task-doc links
+                        for (const op of dedupedTaskDocLinkOps) {
+                            const docId = resolveDocKey(op.data.docKey);
+                            if (!docId) {
+                                skipped++;
+                                continue;
+                            }
+                            if (checkTaskDocLinkStmt.get(op.data.taskId, docId, op.data.linkType)) {
+                                skipped++;
+                                continue;
+                            }
+                            try {
+                                insertTaskDocLinkStmt.run(op.data.taskId, docId, op.data.linkType, op.ts);
+                                imported++;
+                            }
+                            catch {
+                                // Skip FK failures (task may not exist)
+                                skipped++;
+                            }
+                        }
+                        // 4. Import invariants (use op.id as the canonical invariant ID)
+                        for (const op of dedupedInvariantOps) {
+                            if (findInvariantStmt.get(op.id)) {
+                                skipped++;
+                                continue;
+                            }
+                            const docId = resolveDocKey(op.data.docKey);
+                            if (!docId) {
+                                skipped++;
+                                continue;
+                            }
+                            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 })
+            });
+        }),
+        exportLabels: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_LABELS_JSONL_PATH);
+            // Read labels via raw SQL (no repository layer exists)
+            const labels = yield* Effect.try({
+                try: () => db.prepare("SELECT * FROM task_labels").all(),
+                catch: (cause) => new DatabaseError({ cause })
+            });
+            const labelNameMap = new Map();
+            for (const l of labels) {
+                labelNameMap.set(l.id, l.name);
+            }
+            const labelOps = labels.map(labelRowToUpsertOp);
+            // Read label assignments
+            const assignments = yield* Effect.try({
+                try: () => db.prepare("SELECT * FROM task_label_assignments").all(),
+                catch: (cause) => new DatabaseError({ cause })
+            });
+            const assignmentOps = assignments
+                .map(a => labelAssignmentToUpsertOp(a, labelNameMap))
+                .filter((op) => op !== null);
+            const allOps = [...labelOps, ...assignmentOps];
+            allOps.sort((a, b) => a.ts.localeCompare(b.ts));
+            const jsonl = allOps.map(op => JSON.stringify(op)).join("\n");
+            yield* atomicWrite(filePath, jsonl + (jsonl.length > 0 ? "\n" : ""));
+            return { opCount: allOps.length, path: filePath };
+        }),
+        importLabels: (path) => Effect.gen(function* () {
+            const filePath = resolve(path ?? DEFAULT_LABELS_JSONL_PATH);
+            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 lines = content.trim().split("\n").filter(Boolean);
+            if (lines.length === 0)
+                return EMPTY_ENTITY_IMPORT_RESULT;
+            const labelOps = [];
+            const assignmentOps = [];
+            for (const line of lines) {
+                const parsed = yield* Effect.try({
+                    try: () => JSON.parse(line),
+                    catch: (cause) => new ValidationError({ reason: `Invalid JSON: ${cause}` })
+                });
+                const opType = parsed.op;
+                if (opType === "label_upsert") {
+                    labelOps.push(yield* Effect.try({
+                        try: () => Schema.decodeUnknownSync(LabelUpsertOpSchema)(parsed),
+                        catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
+                    }));
+                }
+                else if (opType === "label_assignment_upsert") {
+                    assignmentOps.push(yield* Effect.try({
+                        try: () => Schema.decodeUnknownSync(LabelAssignmentUpsertOpSchema)(parsed),
+                        catch: (cause) => new ValidationError({ reason: `Schema validation failed: ${cause}` })
+                    }));
+                }
+            }
+            // Build existing label hashes
+            const existingLabels = yield* Effect.try({
+                try: () => db.prepare("SELECT * FROM task_labels").all(),
+                catch: (cause) => new DatabaseError({ cause })
+            });
+            const existingLabelHashes = new Set(existingLabels.map(l => contentHash(l.name.toLowerCase())));
+            const findLabelByNameStmt = db.prepare("SELECT id FROM task_labels WHERE lower(name) = lower(?)");
+            const insertLabelStmt = db.prepare("INSERT INTO task_labels (name, color, created_at, updated_at) VALUES (?, ?, ?, ?)");
+            const checkAssignmentStmt = db.prepare("SELECT 1 FROM task_label_assignments WHERE task_id = ? AND label_id = ?");
+            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 {
+                        let imported = 0;
+                        let skipped = 0;
+                        const newLabelNameToId = new Map();
+                        // 1. Import labels (dedup by lower(name))
+                        for (const op of labelOps) {
+                            if (existingLabelHashes.has(op.contentHash)) {
+                                // Still populate the name map for assignment resolution
+                                const existing = findLabelByNameStmt.get(op.data.name);
+                                if (existing)
+                                    newLabelNameToId.set(op.data.name.toLowerCase(), existing.id);
+                                skipped++;
+                                continue;
+                            }
+                            const existing = findLabelByNameStmt.get(op.data.name);
+                            if (existing) {
+                                newLabelNameToId.set(op.data.name.toLowerCase(), existing.id);
+                                skipped++;
+                                continue;
+                            }
+                            const result = insertLabelStmt.run(op.data.name, op.data.color, op.ts, op.ts);
+                            newLabelNameToId.set(op.data.name.toLowerCase(), result.lastInsertRowid);
+                            imported++;
+                        }
+                        // Helper: resolve label name to ID
+                        const resolveLabelId = (name) => {
+                            const newId = newLabelNameToId.get(name.toLowerCase());
+                            if (newId !== undefined)
+                                return newId;
+                            const row = findLabelByNameStmt.get(name);
+                            return row?.id;
+                        };
+                        // 2. Import label assignments
+                        for (const op of assignmentOps) {
+                            const labelId = resolveLabelId(op.data.labelName);
+                            if (!labelId) {
+                                skipped++;
+                                continue;
+                            }
+                            if (checkAssignmentStmt.get(op.data.taskId, labelId)) {
+                                skipped++;
+                                continue;
+                            }
+                            try {
+                                insertAssignmentStmt.run(op.data.taskId, labelId, op.ts);
+                                imported++;
+                            }
+                            catch {
+                                // Skip FK failures (task may not exist)
+                                skipped++;
+                            }
+                        }
+                        db.exec("COMMIT");
+                        return { imported, skipped };
+                    }
+                    catch (e) {
+                        try {
+                            db.exec("ROLLBACK");
+                        }
+                        catch { /* no active transaction */ }
+                        throw e;
+                    }
+                },
+                catch: (cause) => new DatabaseError({ cause })
+            });
+        }),
+        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 };
+        }),
+        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 };
+        })
     };
+    return syncService;
 }));
 //# sourceMappingURL=sync-service.js.map