paths-engine 0.0.0-stage → 0.1.0

package/dist/core/db/store.js

@@ -0,0 +1,1054 @@
+const VALID_SYNC_TABLES = new Set([
+    'projects',
+    'lineages',
+    'nodes',
+    'knowledge',
+    'knowledge_confirmations',
+    'todos',
+]);
+function assertValidSyncTable(table) {
+    if (!VALID_SYNC_TABLES.has(table)) {
+        throw new Error(`Table "${table}" is not a valid syncable table.`);
+    }
+}
+function assertRowAffected(changes, entityName, id) {
+    if (changes === 0) {
+        throw new Error(`${entityName} ${id} does not exist.`);
+    }
+}
+function clampSearchLimit(limit) {
+    return Number.isInteger(limit) ? Math.min(Math.max(limit, 1), 100) : 20;
+}
+function escapeLikeWildcards(value) {
+    return value.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
+}
+function buildLineageFilterClause(lineageId) {
+    return lineageId !== undefined ? ' AND (lineage_id IS NULL OR lineage_id = ?)' : '';
+}
+const PLAN_CONTENT_FIELDS = [
+    { key: 'title', column: 'title' },
+    { key: 'intent', column: 'intent' },
+    { key: 'approach', column: 'approach' },
+    { key: 'definitionOfDone', column: 'definition_of_done' },
+];
+function buildPlanUpdateAssignments(fields) {
+    const assignments = [];
+    const params = [];
+    for (const { key, column } of PLAN_CONTENT_FIELDS) {
+        const value = fields[key];
+        if (value !== undefined) {
+            assignments.push(`${column} = ?`);
+            params.push(value);
+        }
+    }
+    return { assignments, params };
+}
+export class SqliteStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    statementCache = new Map();
+    getPreparedStatement(sql) {
+        let stmt = this.statementCache.get(sql);
+        if (!stmt) {
+            stmt = this.db.prepare(sql);
+            this.statementCache.set(sql, stmt);
+        }
+        return stmt;
+    }
+    transaction(fn) {
+        return this.db.transaction(fn)();
+    }
+    getProjectByKey(key) {
+        const stmt = this.getPreparedStatement('SELECT * FROM projects WHERE key = ?');
+        return stmt.get(key);
+    }
+    getProjectById(id) {
+        const stmt = this.getPreparedStatement('SELECT * FROM projects WHERE id = ?');
+        return stmt.get(id);
+    }
+    getLatestProject() {
+        const stmt = this.getPreparedStatement('SELECT * FROM projects WHERE path_hint IS NOT NULL ORDER BY id DESC LIMIT 1');
+        return stmt.get();
+    }
+    upsertProject(key, pathHint, name) {
+        const existing = this.getProjectByKey(key);
+        if (existing) {
+            const updateStmt = this.db.prepare('UPDATE projects SET path_hint = ? WHERE id = ?');
+            updateStmt.run(pathHint, existing.id);
+            return { ...existing, path_hint: pathHint };
+        }
+        const createdAt = new Date().toISOString();
+        const insertStmt = this.db.prepare('INSERT INTO projects (key, path_hint, name, current_lineage_id, created_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version) VALUES (?, ?, ?, ?, ?, NULL, NULL, NULL, 0, 1)');
+        const info = insertStmt.run(key, pathHint, name ?? null, null, createdAt);
+        return {
+            id: Number(info.lastInsertRowid),
+            key,
+            path_hint: pathHint,
+            name: name ?? null,
+            current_lineage_id: null,
+            created_at: createdAt,
+            sync_uuid: null,
+            sync_hlc: null,
+            sync_origin_device: null,
+            sync_is_tombstone: 0,
+            sync_version: 1,
+        };
+    }
+    getIdentityRow(projectId) {
+        const stmt = this.getPreparedStatement('SELECT * FROM identity WHERE project_id = ?');
+        return stmt.get(projectId);
+    }
+    upsertIdentityRow(projectId, fields, updatedAt) {
+        const existing = this.getIdentityRow(projectId);
+        const fieldValues = [
+            fields.project_name ?? null,
+            fields.purpose ?? null,
+            fields.architecture ?? null,
+            fields.tech_stack ?? null,
+            fields.coding_standards ?? null,
+            fields.folder_structure ?? null,
+            fields.scope ?? null,
+            fields.definition_of_done ?? null,
+        ];
+        if (existing) {
+            this.getPreparedStatement(`
+        UPDATE identity SET
+          project_name = COALESCE(?, project_name),
+          purpose = COALESCE(?, purpose),
+          architecture = COALESCE(?, architecture),
+          tech_stack = COALESCE(?, tech_stack),
+          coding_standards = COALESCE(?, coding_standards),
+          folder_structure = COALESCE(?, folder_structure),
+          scope = COALESCE(?, scope),
+          definition_of_done = COALESCE(?, definition_of_done),
+          updated_at = ?
+        WHERE project_id = ?
+      `).run(...fieldValues, updatedAt, projectId);
+            return this.getIdentityRow(projectId);
+        }
+        this.getPreparedStatement(`
+      INSERT INTO identity (
+        project_id, project_name, purpose, architecture, tech_stack,
+        coding_standards, folder_structure, scope, definition_of_done, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(projectId, ...fieldValues, updatedAt);
+        return this.getIdentityRow(projectId);
+    }
+    createLineageRow(projectId, name) {
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare('INSERT INTO lineages (project_id, name, status, created_at, last_active_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version) VALUES (?, ?, ?, ?, ?, NULL, NULL, NULL, 0, 1)');
+        const info = stmt.run(projectId, name, 'active', now, now);
+        return {
+            id: Number(info.lastInsertRowid),
+            project_id: projectId,
+            name,
+            status: 'active',
+            created_at: now,
+            last_active_at: now,
+            sync_uuid: null,
+            sync_hlc: null,
+            sync_origin_device: null,
+            sync_is_tombstone: 0,
+            sync_version: 1,
+        };
+    }
+    getLineagesByProjectId(projectId) {
+        const stmt = this.getPreparedStatement('SELECT * FROM lineages WHERE project_id = ? ORDER BY id ASC');
+        return stmt.all(projectId);
+    }
+    getLineageById(id) {
+        const stmt = this.getPreparedStatement('SELECT * FROM lineages WHERE id = ?');
+        return stmt.get(id);
+    }
+    touchLineageRow(id) {
+        const now = new Date().toISOString();
+        const stmt = this.getPreparedStatement('UPDATE lineages SET last_active_at = ? WHERE id = ?');
+        stmt.run(now, id);
+    }
+    setCurrentLineageId(projectId, lineageId) {
+        const stmt = this.getPreparedStatement('UPDATE projects SET current_lineage_id = ? WHERE id = ?');
+        stmt.run(lineageId, projectId);
+    }
+    createNodeRow(lineageId, tool, summary, parentNodeId, filesTouched, nodeType = 'session') {
+        const createdAt = new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO nodes (lineage_id, tool, summary, files_touched, parent_node_id, created_at, node_type, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version)
+      VALUES (?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL, 0, 1)
+    `);
+        const info = stmt.run(lineageId, tool, summary, filesTouched ?? null, parentNodeId ?? null, createdAt, nodeType);
+        return {
+            id: Number(info.lastInsertRowid),
+            lineage_id: lineageId,
+            tool,
+            summary,
+            files_touched: filesTouched ?? null,
+            parent_node_id: parentNodeId ?? null,
+            created_at: createdAt,
+            node_type: nodeType,
+            sync_uuid: null,
+            sync_hlc: null,
+            sync_origin_device: null,
+            sync_is_tombstone: 0,
+            sync_version: 1,
+        };
+    }
+    getSessionNodesByLineageId(lineageId, limit) {
+        const limitClause = limit !== undefined ? ' LIMIT ?' : '';
+        const sql = `SELECT * FROM nodes WHERE lineage_id = ? AND node_type = 'session' ORDER BY id DESC${limitClause}`;
+        const params = limit !== undefined ? [lineageId, limit] : [lineageId];
+        return this.getPreparedStatement(sql).all(...params);
+    }
+    getAllNodesByLineageId(lineageId, limit) {
+        const limitClause = limit !== undefined ? ' LIMIT ?' : '';
+        const sql = `SELECT * FROM nodes WHERE lineage_id = ? ORDER BY id DESC${limitClause}`;
+        const params = limit !== undefined ? [lineageId, limit] : [lineageId];
+        return this.getPreparedStatement(sql).all(...params);
+    }
+    getNodesByLineageId(lineageId, limit) {
+        return this.getSessionNodesByLineageId(lineageId, limit);
+    }
+    getNodesByLineageIds(lineageIds, limitPerLineage) {
+        if (lineageIds.length === 0) {
+            return [];
+        }
+        const placeholders = lineageIds.map(() => '?').join(', ');
+        if (limitPerLineage !== undefined) {
+            const sql = `
+        WITH ranked_nodes AS (
+          SELECT *, ROW_NUMBER() OVER (PARTITION BY lineage_id ORDER BY id DESC) AS rn
+          FROM nodes
+          WHERE lineage_id IN (${placeholders}) AND node_type = 'session'
+        )
+        SELECT 
+          id, lineage_id, tool, summary, files_touched, parent_node_id, 
+          created_at, node_type, sync_uuid, sync_hlc, sync_origin_device, 
+          sync_is_tombstone, sync_version
+        FROM ranked_nodes 
+        WHERE rn <= ? 
+        ORDER BY lineage_id ASC, id DESC
+      `;
+            return this.db.prepare(sql).all(...lineageIds, limitPerLineage);
+        }
+        const sql = `
+      SELECT * FROM nodes
+      WHERE lineage_id IN (${placeholders}) AND node_type = 'session'
+      ORDER BY lineage_id ASC, id DESC
+    `;
+        return this.db.prepare(sql).all(...lineageIds);
+    }
+    searchNodes(projectId, query, lineageId, limit = 20) {
+        const trimmed = query.trim();
+        if (!trimmed) {
+            return [];
+        }
+        const safeLimit = clampSearchLimit(limit);
+        const pattern = `%${escapeLikeWildcards(trimmed)}%`;
+        let sql = `
+      SELECT 
+        n.id,
+        n.lineage_id,
+        l.name AS lineage_name,
+        l.project_id,
+        n.tool,
+        n.summary,
+        n.files_touched,
+        n.created_at,
+        n.node_type
+      FROM nodes n
+      JOIN lineages l ON n.lineage_id = l.id
+      WHERE l.project_id = ?
+        AND n.node_type = 'session'
+        AND (
+          n.summary LIKE ? ESCAPE '\\'
+          OR (n.files_touched IS NOT NULL AND n.files_touched LIKE ? ESCAPE '\\')
+        )
+    `;
+        const params = [projectId, pattern, pattern];
+        if (lineageId !== undefined) {
+            sql += ` AND n.lineage_id = ?`;
+            params.push(lineageId);
+        }
+        sql += ` ORDER BY n.id DESC LIMIT ?`;
+        params.push(safeLimit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    getSessionNodesByTouchedFiles(projectId, filePaths, lineageId, limit = 50) {
+        const targets = filePaths
+            .map((file) => file.trim())
+            .filter((file) => file.length > 0);
+        if (targets.length === 0) {
+            return [];
+        }
+        const matchClauses = targets
+            .map(() => `(n.files_touched LIKE ? ESCAPE '\\')`)
+            .join(' OR ');
+        let sql = `
+      SELECT n.*
+      FROM nodes n
+      JOIN lineages l ON n.lineage_id = l.id
+      WHERE l.project_id = ?
+        AND n.node_type = 'session'
+        AND n.files_touched IS NOT NULL
+        AND (${matchClauses})
+    `;
+        const params = [
+            projectId,
+            ...targets.map((file) => `%${escapeLikeWildcards(file)}%`),
+        ];
+        if (lineageId !== undefined) {
+            sql += ` AND n.lineage_id = ?`;
+            params.push(lineageId);
+        }
+        sql += ` ORDER BY n.id DESC LIMIT ?`;
+        params.push(clampSearchLimit(limit));
+        return this.db.prepare(sql).all(...params);
+    }
+    getLatestNodeByLineageId(lineageId) {
+        const stmt = this.getPreparedStatement('SELECT * FROM nodes WHERE lineage_id = ? ORDER BY id DESC LIMIT 1');
+        return stmt.get(lineageId);
+    }
+    getNodeById(id) {
+        const stmt = this.getPreparedStatement('SELECT * FROM nodes WHERE id = ?');
+        return stmt.get(id);
+    }
+    findNodesByIds(nodeIds) {
+        if (nodeIds.length === 0) {
+            return [];
+        }
+        const placeholders = nodeIds.map(() => '?').join(', ');
+        return this.db.prepare(`SELECT * FROM nodes WHERE id IN (${placeholders})`).all(...nodeIds);
+    }
+    countNodesByLineageId(lineageId) {
+        const stmt = this.getPreparedStatement("SELECT COUNT(*) as count FROM nodes WHERE lineage_id = ? AND node_type = 'session'");
+        const row = stmt.get(lineageId);
+        return Number(row.count);
+    }
+    countNodesByLineageIds(lineageIds) {
+        if (lineageIds.length === 0) {
+            return [];
+        }
+        // Prepared fresh on every call: the placeholder count varies with input
+        // length, so a shared cached statement cannot serve all shapes.
+        const placeholders = lineageIds.map(() => '?').join(', ');
+        const stmt = this.db.prepare(`SELECT lineage_id, COUNT(*) as count FROM nodes WHERE lineage_id IN (${placeholders}) AND node_type = 'session' GROUP BY lineage_id`);
+        return stmt.all(...lineageIds);
+    }
+    findLineageIdsByNodeIds(nodeIds) {
+        if (nodeIds.length === 0) {
+            return [];
+        }
+        const placeholders = nodeIds.map(() => '?').join(', ');
+        const stmt = this.db.prepare(`SELECT id, lineage_id FROM nodes WHERE id IN (${placeholders})`);
+        return stmt.all(...nodeIds);
+    }
+    createRollupRow(lineageId, fromNodeId, toNodeId, rollupNodeId, createdAt) {
+        const stmt = this.db.prepare(`
+      INSERT INTO node_rollups (id, lineage_id, from_node_id, to_node_id, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(rollupNodeId, lineageId, fromNodeId, toNodeId, createdAt);
+        return {
+            id: rollupNodeId,
+            lineage_id: lineageId,
+            from_node_id: fromNodeId,
+            to_node_id: toNodeId,
+            created_at: createdAt,
+        };
+    }
+    getRollupsByLineageId(lineageId) {
+        const stmt = this.getPreparedStatement('SELECT * FROM node_rollups WHERE lineage_id = ? ORDER BY from_node_id ASC');
+        return stmt.all(lineageId);
+    }
+    createTodoRow(projectId, text, lineageId, originNodeId, planId) {
+        const createdAt = new Date().toISOString();
+        const stmt = this.db.prepare('INSERT INTO todos (project_id, lineage_id, origin_node_id, plan_id, text, done, created_at, done_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version) VALUES (?, ?, ?, ?, ?, 0, ?, NULL, NULL, NULL, NULL, 0, 1)');
+        const info = stmt.run(projectId, lineageId ?? null, originNodeId ?? null, planId ?? null, text, createdAt);
+        return {
+            id: Number(info.lastInsertRowid),
+            project_id: projectId,
+            lineage_id: lineageId ?? null,
+            origin_node_id: originNodeId ?? null,
+            plan_id: planId ?? null,
+            text,
+            done: 0,
+            created_at: createdAt,
+            done_at: null,
+            sync_uuid: null,
+            sync_hlc: null,
+            sync_origin_device: null,
+            sync_is_tombstone: 0,
+            sync_version: 1,
+        };
+    }
+    findOpenTodosByProjectId(projectId, lineageId, limit) {
+        const lineageClause = buildLineageFilterClause(lineageId);
+        const limitClause = limit !== undefined ? ' LIMIT ?' : '';
+        const sql = `SELECT * FROM todos WHERE project_id = ? AND done = 0${lineageClause} ORDER BY created_at ASC, id ASC${limitClause}`;
+        const params = [
+            projectId,
+            ...(lineageId !== undefined ? [lineageId] : []),
+            ...(limit !== undefined ? [limit] : []),
+        ];
+        return this.getPreparedStatement(sql).all(...params);
+    }
+    countOpenTodosByProjectId(projectId, lineageId) {
+        const lineageClause = buildLineageFilterClause(lineageId);
+        const sql = `SELECT COUNT(*) as count FROM todos WHERE project_id = ? AND done = 0${lineageClause}`;
+        const params = lineageId !== undefined ? [projectId, lineageId] : [projectId];
+        const row = this.getPreparedStatement(sql).get(...params);
+        return Number(row.count);
+    }
+    markTodoDoneRow(id, doneAt) {
+        const stmt = this.db.prepare('UPDATE todos SET done = 1, done_at = ? WHERE id = ?');
+        const info = stmt.run(doneAt, id);
+        assertRowAffected(info.changes, 'Todo', id);
+        return this.getTodoById(id);
+    }
+    markTodoDoneById(id, doneAt) {
+        return this.markTodoDoneRow(id, doneAt);
+    }
+    getTodoById(id) {
+        const stmt = this.getPreparedStatement('SELECT * FROM todos WHERE id = ?');
+        return stmt.get(id);
+    }
+    createKnowledgeRow(projectId, category, fact, why, originNodeId, supersedesId) {
+        const createdAt = new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO knowledge (
+        project_id, category, fact, why, origin_node_id, supersedes_id,
+        status, created_at, last_referenced_at, legacy_reference_count,
+        conflicted_at, conflicted_reason, resolved_at, resolved_by, resolution_knowledge_id,
+        sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version
+      ) VALUES (?, ?, ?, ?, ?, ?, 'active', ?, NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 1)
+    `);
+        const info = stmt.run(projectId, category, fact, why, originNodeId ?? null, supersedesId ?? null, createdAt);
+        return {
+            id: Number(info.lastInsertRowid),
+            project_id: projectId,
+            category,
+            fact,
+            why,
+            origin_node_id: originNodeId ?? null,
+            supersedes_id: supersedesId ?? null,
+            status: 'active',
+            created_at: createdAt,
+            last_referenced_at: null,
+            legacy_reference_count: 0,
+            conflicted_at: null,
+            conflicted_reason: null,
+            resolved_at: null,
+            resolved_by: null,
+            resolution_knowledge_id: null,
+            sync_uuid: null,
+            sync_hlc: null,
+            sync_origin_device: null,
+            sync_is_tombstone: 0,
+            sync_version: 1,
+        };
+    }
+    markKnowledgeSupersededRow(id) {
+        const stmt = this.db.prepare("UPDATE knowledge SET status = 'superseded' WHERE id = ?");
+        const info = stmt.run(id);
+        assertRowAffected(info.changes, 'Knowledge', id);
+    }
+    linkKnowledgeToOriginNodeRow(knowledgeId, originNodeId) {
+        const stmt = this.db.prepare('UPDATE knowledge SET origin_node_id = ? WHERE id = ?');
+        const info = stmt.run(originNodeId, knowledgeId);
+        assertRowAffected(info.changes, 'Knowledge', knowledgeId);
+    }
+    markKnowledgeConflictedRow(id, conflictedAt, reason) {
+        const stmt = this.db.prepare(`
+      UPDATE knowledge SET
+        status = 'conflicted',
+        conflicted_at = ?,
+        conflicted_reason = ?
+      WHERE id = ?
+    `);
+        const info = stmt.run(conflictedAt, reason, id);
+        assertRowAffected(info.changes, 'Knowledge', id);
+    }
+    resolveKnowledgeConflictRow(id, resolvedAt, resolvedBy, resolutionKnowledgeId, newStatus) {
+        const stmt = this.db.prepare(`
+      UPDATE knowledge SET
+        status = ?,
+        resolved_at = ?,
+        resolved_by = ?,
+        resolution_knowledge_id = ?
+      WHERE id = ?
+    `);
+        const info = stmt.run(newStatus, resolvedAt, resolvedBy, resolutionKnowledgeId, id);
+        assertRowAffected(info.changes, 'Knowledge', id);
+    }
+    findActiveKnowledgeByProjectId(projectId) {
+        const stmt = this.getPreparedStatement("SELECT * FROM knowledge WHERE project_id = ? AND status = 'active' ORDER BY created_at ASC, id ASC");
+        return stmt.all(projectId);
+    }
+    findConflictedKnowledgeByProjectId(projectId) {
+        const stmt = this.getPreparedStatement("SELECT * FROM knowledge WHERE project_id = ? AND status = 'conflicted' ORDER BY created_at ASC, id ASC");
+        return stmt.all(projectId);
+    }
+    findAllKnowledgeByProjectId(projectId) {
+        const stmt = this.getPreparedStatement('SELECT * FROM knowledge WHERE project_id = ? ORDER BY created_at DESC, id DESC');
+        return stmt.all(projectId);
+    }
+    searchKnowledge(projectId, query, limit) {
+        const trimmed = query.trim();
+        if (!trimmed) {
+            return [];
+        }
+        const pattern = `%${escapeLikeWildcards(trimmed)}%`;
+        // LIKE shape varies with limit, so this stays uncached like searchNodes.
+        let sql = `
+      SELECT * FROM knowledge
+      WHERE project_id = ?
+        AND (fact LIKE ? ESCAPE '\\' OR why LIKE ? ESCAPE '\\')
+      ORDER BY created_at DESC, id DESC
+    `;
+        const params = [projectId, pattern, pattern];
+        if (limit !== undefined) {
+            sql += ' LIMIT ?';
+            params.push(clampSearchLimit(limit));
+        }
+        return this.db.prepare(sql).all(...params);
+    }
+    getKnowledgeById(id) {
+        const stmt = this.getPreparedStatement('SELECT * FROM knowledge WHERE id = ?');
+        return stmt.get(id);
+    }
+    getKnowledgeByOriginNodeIds(originNodeIds) {
+        if (originNodeIds.length === 0) {
+            return [];
+        }
+        // Prepared fresh on every call: the placeholder count varies with input
+        // length, so a shared cached statement cannot serve all shapes.
+        const placeholders = originNodeIds.map(() => '?').join(', ');
+        return this.db.prepare(`SELECT * FROM knowledge WHERE origin_node_id IN (${placeholders}) AND status != 'superseded' ORDER BY id DESC`).all(...originNodeIds);
+    }
+    createKnowledgeConfirmationRow(knowledgeId, originNodeId, tool) {
+        const confirmedAt = new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO knowledge_confirmations (knowledge_id, origin_node_id, tool, confirmed_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version)
+      VALUES (?, ?, ?, ?, NULL, NULL, NULL, 0, 1)
+    `);
+        const info = stmt.run(knowledgeId, originNodeId ?? null, tool ?? null, confirmedAt);
+        return {
+            id: Number(info.lastInsertRowid),
+            knowledge_id: knowledgeId,
+            origin_node_id: originNodeId ?? null,
+            tool: tool ?? null,
+            confirmed_at: confirmedAt,
+            sync_uuid: null,
+            sync_hlc: null,
+            sync_origin_device: null,
+            sync_is_tombstone: 0,
+            sync_version: 1,
+        };
+    }
+    findConfirmationsByKnowledgeId(knowledgeId) {
+        const stmt = this.getPreparedStatement('SELECT * FROM knowledge_confirmations WHERE knowledge_id = ? ORDER BY confirmed_at ASC, id ASC');
+        return stmt.all(knowledgeId);
+    }
+    countConfirmationsByKnowledgeId(knowledgeId) {
+        const stmt = this.getPreparedStatement('SELECT COUNT(*) as count FROM knowledge_confirmations WHERE knowledge_id = ?');
+        const row = stmt.get(knowledgeId);
+        return Number(row.count);
+    }
+    countConfirmationsByKnowledgeIds(knowledgeIds) {
+        if (knowledgeIds.length === 0) {
+            return [];
+        }
+        // Prepared fresh on every call: the placeholder count varies with input
+        // length, so a shared cached statement cannot serve all shapes.
+        const placeholders = knowledgeIds.map(() => '?').join(', ');
+        const stmt = this.db.prepare(`SELECT knowledge_id, COUNT(*) as count FROM knowledge_confirmations WHERE knowledge_id IN (${placeholders}) GROUP BY knowledge_id`);
+        return stmt.all(...knowledgeIds);
+    }
+    createPlanRow(input) {
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO plans (
+        project_id, lineage_id, title, intent, approach, definition_of_done,
+        status, created_at, updated_at,
+        completed_at, completion_summary, abandoned_at, abandonment_reason, replaced_by_plan_id,
+        sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version
+      ) VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 1)
+    `);
+        const info = stmt.run(input.projectId, input.lineageId ?? null, input.title, input.intent, input.approach, input.definitionOfDone, now, now);
+        return {
+            id: Number(info.lastInsertRowid),
+            project_id: input.projectId,
+            lineage_id: input.lineageId ?? null,
+            title: input.title,
+            intent: input.intent,
+            approach: input.approach,
+            definition_of_done: input.definitionOfDone,
+            status: 'active',
+            created_at: now,
+            updated_at: now,
+            completed_at: null,
+            completion_summary: null,
+            abandoned_at: null,
+            abandonment_reason: null,
+            replaced_by_plan_id: null,
+            sync_uuid: null,
+            sync_hlc: null,
+            sync_origin_device: null,
+            sync_is_tombstone: 0,
+            sync_version: 1,
+        };
+    }
+    getPlanById(id) {
+        const stmt = this.getPreparedStatement('SELECT * FROM plans WHERE id = ?');
+        return stmt.get(id);
+    }
+    getActivePlanByProjectId(projectId) {
+        const stmt = this.getPreparedStatement("SELECT * FROM plans WHERE project_id = ? AND status = 'active' ORDER BY id ASC LIMIT 1");
+        return stmt.get(projectId);
+    }
+    getLatestPlanByProjectId(projectId) {
+        const stmt = this.getPreparedStatement('SELECT * FROM plans WHERE project_id = ? ORDER BY id DESC LIMIT 1');
+        return stmt.get(projectId);
+    }
+    getPlansByProjectId(projectId, includeInactive) {
+        const sql = includeInactive
+            ? 'SELECT * FROM plans WHERE project_id = ? ORDER BY created_at ASC, id ASC'
+            : "SELECT * FROM plans WHERE project_id = ? AND status = 'active' ORDER BY created_at ASC, id ASC";
+        return this.getPreparedStatement(sql).all(projectId);
+    }
+    markPlanCompletedRow(id, summary, completedAt) {
+        const stmt = this.db.prepare(`
+      UPDATE plans SET
+        status = 'completed',
+        completion_summary = ?,
+        completed_at = ?,
+        updated_at = ?
+      WHERE id = ?
+    `);
+        const info = stmt.run(summary, completedAt, completedAt, id);
+        assertRowAffected(info.changes, 'Plan', id);
+        return this.getPlanById(id);
+    }
+    markPlanAbandonedRow(id, reason, abandonedAt) {
+        const stmt = this.db.prepare(`
+      UPDATE plans SET
+        status = 'abandoned',
+        abandonment_reason = ?,
+        abandoned_at = ?,
+        updated_at = ?
+      WHERE id = ?
+    `);
+        const info = stmt.run(reason, abandonedAt, abandonedAt, id);
+        assertRowAffected(info.changes, 'Plan', id);
+        return this.getPlanById(id);
+    }
+    markPlanReplacedRow(id, replacedByPlanId, replacedAt) {
+        const stmt = this.db.prepare(`
+      UPDATE plans SET
+        status = 'replaced',
+        replaced_by_plan_id = ?,
+        updated_at = ?
+      WHERE id = ?
+    `);
+        const info = stmt.run(replacedByPlanId, replacedAt, id);
+        assertRowAffected(info.changes, 'Plan', id);
+        return this.getPlanById(id);
+    }
+    updatePlanContentRow(id, fields, updatedAt) {
+        const { assignments, params } = buildPlanUpdateAssignments(fields);
+        assignments.push('updated_at = ?');
+        params.push(updatedAt, id);
+        const info = this.db
+            .prepare(`UPDATE plans SET ${assignments.join(', ')} WHERE id = ?`)
+            .run(...params);
+        assertRowAffected(info.changes, 'Plan', id);
+        return this.getPlanById(id);
+    }
+    getInstallationIdentity(deviceId) {
+        if (deviceId) {
+            const stmt = this.getPreparedStatement('SELECT * FROM installation_identity WHERE device_id = ?');
+            return stmt.get(deviceId);
+        }
+        return this.getPrimaryInstallationIdentity();
+    }
+    getPrimaryInstallationIdentity() {
+        const stmt = this.getPreparedStatement('SELECT * FROM installation_identity ORDER BY created_at ASC LIMIT 1');
+        return stmt.get();
+    }
+    createInstallationIdentity(deviceId, deviceName) {
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO installation_identity (device_id, device_name, last_sequence, created_at)
+      VALUES (?, ?, 0, ?)
+    `);
+        stmt.run(deviceId, deviceName ?? null, now);
+        return {
+            device_id: deviceId,
+            device_name: deviceName ?? null,
+            last_sequence: 0,
+            created_at: now,
+        };
+    }
+    allocateDeviceSequence(deviceId) {
+        const stmt = this.getPreparedStatement(`
+      UPDATE installation_identity
+      SET last_sequence = last_sequence + 1
+      WHERE device_id = ?
+      RETURNING last_sequence
+    `);
+        const row = stmt.get(deviceId);
+        if (!row) {
+            throw new Error(`Installation identity for device ${deviceId} does not exist.`);
+        }
+        return row.last_sequence;
+    }
+    getHlcState(deviceId) {
+        const stmt = this.getPreparedStatement('SELECT * FROM hlc_state WHERE device_id = ?');
+        return stmt.get(deviceId);
+    }
+    upsertHlcState(deviceId, physicalTimeMs, logicalCounter, updatedAt) {
+        const stmt = this.getPreparedStatement(`
+      INSERT INTO hlc_state (device_id, physical_time_ms, logical_counter, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(device_id) DO UPDATE SET
+        physical_time_ms = excluded.physical_time_ms,
+        logical_counter = excluded.logical_counter,
+        updated_at = excluded.updated_at
+    `);
+        stmt.run(deviceId, physicalTimeMs, logicalCounter, updatedAt);
+        return {
+            device_id: deviceId,
+            physical_time_ms: physicalTimeMs,
+            logical_counter: logicalCounter,
+            updated_at: updatedAt,
+        };
+    }
+    createExternalEventRow(row) {
+        const stmt = this.db.prepare(`
+      INSERT INTO external_events (
+        project_id, external_event_id, source_system, event_type,
+        source_record, occurred_at, ingested_at, created_at,
+        canonical_entity_type, canonical_entity_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const info = stmt.run(row.project_id, row.external_event_id, row.source_system, row.event_type, row.source_record, row.occurred_at, row.ingested_at, row.created_at, row.canonical_entity_type ?? null, row.canonical_entity_id ?? null);
+        return {
+            id: Number(info.lastInsertRowid),
+            ...row,
+        };
+    }
+    findExternalEvent(projectId, sourceSystem, externalEventId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM external_events
+      WHERE project_id = ? AND source_system = ? AND external_event_id = ?
+    `);
+        return stmt.get(projectId, sourceSystem, externalEventId);
+    }
+    findExternalEventById(id) {
+        const stmt = this.db.prepare('SELECT * FROM external_events WHERE id = ?');
+        return stmt.get(id);
+    }
+    linkExternalEventCanonical(id, canonicalEntityType, canonicalEntityId) {
+        const stmt = this.db.prepare(`
+      UPDATE external_events
+      SET canonical_entity_type = ?, canonical_entity_id = ?
+      WHERE id = ?
+    `);
+        stmt.run(canonicalEntityType, canonicalEntityId, id);
+    }
+    listExternalEventsByProject(projectId) {
+        const stmt = this.db.prepare('SELECT * FROM external_events WHERE project_id = ? ORDER BY occurred_at DESC, id DESC');
+        return stmt.all(projectId);
+    }
+    upsertEmbeddingRow(row) {
+        const stmt = this.db.prepare(`
+      INSERT INTO embeddings (
+        entity_type, entity_id, model_id, dimensions, content_hash, metric, normalization_version, vector, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(entity_type, entity_id, model_id) DO UPDATE SET
+        dimensions = excluded.dimensions,
+        content_hash = excluded.content_hash,
+        metric = excluded.metric,
+        normalization_version = excluded.normalization_version,
+        vector = excluded.vector,
+        created_at = excluded.created_at
+    `);
+        const info = stmt.run(row.entity_type, row.entity_id, row.model_id, row.dimensions, row.content_hash, row.metric, row.normalization_version, row.vector, row.created_at);
+        return {
+            id: Number(info.lastInsertRowid || 0),
+            ...row,
+        };
+    }
+    findEmbedding(entityType, entityId, modelId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM embeddings
+      WHERE entity_type = ? AND entity_id = ? AND model_id = ?
+    `);
+        return stmt.get(entityType, entityId, modelId);
+    }
+    listEmbeddingsForEntities(entityType, entityIds, modelId) {
+        if (entityIds.length === 0) {
+            return [];
+        }
+        const placeholders = entityIds.map(() => '?').join(', ');
+        const stmt = this.db.prepare(`
+      SELECT * FROM embeddings
+      WHERE entity_type = ? AND model_id = ? AND entity_id IN (${placeholders})
+    `);
+        return stmt.all(entityType, modelId, ...entityIds);
+    }
+    deleteEmbedding(entityType, entityId, modelId) {
+        const stmt = this.db.prepare(`
+      DELETE FROM embeddings
+      WHERE entity_type = ? AND entity_id = ? AND model_id = ?
+    `);
+        stmt.run(entityType, entityId, modelId);
+    }
+    createSyncChangeRow(row) {
+        const stmt = this.db.prepare(`
+      INSERT INTO sync_changes (
+        project_key, origin_device_id, origin_sequence, entity_type, entity_uuid,
+        operation, payload, hlc_timestamp, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const info = stmt.run(row.project_key, row.origin_device_id, row.origin_sequence, row.entity_type, row.entity_uuid, row.operation, row.payload, row.hlc_timestamp, row.created_at);
+        return {
+            id: Number(info.lastInsertRowid),
+            ...row,
+        };
+    }
+    findSyncChange(originDeviceId, originSequence) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM sync_changes
+      WHERE origin_device_id = ? AND origin_sequence = ?
+    `);
+        return stmt.get(originDeviceId, originSequence);
+    }
+    listSyncChangesByProject(projectKey) {
+        const stmt = this.db.prepare('SELECT * FROM sync_changes WHERE project_key = ? ORDER BY id ASC');
+        return stmt.all(projectKey);
+    }
+    countSyncChangesByProject(projectKey) {
+        const stmt = this.getPreparedStatement('SELECT COUNT(*) as count FROM sync_changes WHERE project_key = ?');
+        const row = stmt.get(projectKey);
+        return Number(row?.count ?? 0);
+    }
+    listSyncChangesAfter(projectKey, originDeviceId, afterSequence) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM sync_changes
+      WHERE project_key = ? AND origin_device_id = ? AND origin_sequence > ?
+      ORDER BY origin_sequence ASC
+    `);
+        return stmt.all(projectKey, originDeviceId, afterSequence);
+    }
+    createSyncDeferredChangeRow(row) {
+        const stmt = this.db.prepare(`
+      INSERT INTO sync_deferred_changes (
+        project_key, origin_device_id, origin_sequence, entity_type, entity_uuid,
+        missing_dependencies, payload, hlc_timestamp, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const info = stmt.run(row.project_key, row.origin_device_id, row.origin_sequence, row.entity_type, row.entity_uuid, row.missing_dependencies, row.payload, row.hlc_timestamp, row.created_at);
+        return {
+            id: Number(info.lastInsertRowid),
+            ...row,
+        };
+    }
+    findSyncDeferredChange(originDeviceId, originSequence) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM sync_deferred_changes
+      WHERE origin_device_id = ? AND origin_sequence = ?
+    `);
+        return stmt.get(originDeviceId, originSequence);
+    }
+    listSyncDeferredChangesByProject(projectKey) {
+        const stmt = this.db.prepare('SELECT * FROM sync_deferred_changes WHERE project_key = ? ORDER BY id ASC');
+        return stmt.all(projectKey);
+    }
+    countSyncDeferredChangesByProject(projectKey) {
+        const stmt = this.getPreparedStatement('SELECT COUNT(*) as count FROM sync_deferred_changes WHERE project_key = ?');
+        const row = stmt.get(projectKey);
+        return Number(row?.count ?? 0);
+    }
+    deleteSyncDeferredChange(originDeviceId, originSequence) {
+        const stmt = this.db.prepare(`
+      DELETE FROM sync_deferred_changes
+      WHERE origin_device_id = ? AND origin_sequence = ?
+    `);
+        stmt.run(originDeviceId, originSequence);
+    }
+    findLocalIdBySyncUuid(table, syncUuid) {
+        assertValidSyncTable(table);
+        const stmt = this.db.prepare(`SELECT id FROM ${table} WHERE sync_uuid = ?`);
+        const row = stmt.get(syncUuid);
+        return row?.id;
+    }
+    findSyncUuidByLocalId(table, id) {
+        assertValidSyncTable(table);
+        const stmt = this.db.prepare(`SELECT sync_uuid FROM ${table} WHERE id = ?`);
+        const row = stmt.get(id);
+        return row?.sync_uuid ?? undefined;
+    }
+    findEntityBySyncUuid(table, syncUuid) {
+        assertValidSyncTable(table);
+        const stmt = this.db.prepare(`SELECT * FROM ${table} WHERE sync_uuid = ?`);
+        return stmt.get(syncUuid);
+    }
+    updateEntitySyncMetadata(table, id, syncUuid, syncHlc, syncOriginDevice, isTombstone, syncVersion) {
+        assertValidSyncTable(table);
+        const stmt = this.db.prepare(`
+      UPDATE ${table}
+      SET sync_uuid = ?, sync_hlc = ?, sync_origin_device = ?, sync_is_tombstone = ?, sync_version = ?
+      WHERE id = ?
+    `);
+        stmt.run(syncUuid, syncHlc, syncOriginDevice, isTombstone, syncVersion, id);
+    }
+    upsertSyncProject(key, name, pathHint, createdAt, meta) {
+        const existing = this.getPreparedStatement('SELECT * FROM projects WHERE sync_uuid = ? OR key = ?').get(meta.syncUuid, key);
+        if (existing) {
+            return this.getPreparedStatement(`UPDATE projects
+           SET name = COALESCE(?, name),
+               path_hint = COALESCE(?, path_hint),
+               sync_uuid = ?,
+               sync_hlc = ?,
+               sync_origin_device = ?,
+               sync_is_tombstone = ?,
+               sync_version = sync_version + 1
+           WHERE id = ?
+           RETURNING *`)
+                .get(name, pathHint, meta.syncUuid, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone, existing.id);
+        }
+        return this.getPreparedStatement(`INSERT INTO projects (key, name, path_hint, created_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1)
+         RETURNING *`)
+            .get(key, name, pathHint, createdAt, meta.syncUuid, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone);
+    }
+    upsertSyncLineage(projectId, name, status, createdAt, lastActiveAt, meta) {
+        const existing = this.getPreparedStatement('SELECT * FROM lineages WHERE sync_uuid = ?').get(meta.syncUuid);
+        if (existing) {
+            return this.getPreparedStatement(`UPDATE lineages
+           SET name = ?,
+               status = ?,
+               last_active_at = ?,
+               sync_hlc = ?,
+               sync_origin_device = ?,
+               sync_is_tombstone = ?,
+               sync_version = sync_version + 1
+           WHERE id = ?
+           RETURNING *`)
+                .get(name, status, lastActiveAt, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone, existing.id);
+        }
+        return this.getPreparedStatement(`INSERT INTO lineages (project_id, name, status, created_at, last_active_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+         RETURNING *`)
+            .get(projectId, name, status, createdAt, lastActiveAt, meta.syncUuid, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone);
+    }
+    upsertSyncNode(lineageId, parentNodeId, tool, summary, filesTouched, nodeType, createdAt, meta) {
+        const existing = this.getPreparedStatement('SELECT * FROM nodes WHERE sync_uuid = ?').get(meta.syncUuid);
+        if (existing) {
+            return this.getPreparedStatement(`UPDATE nodes
+           SET lineage_id = ?,
+               parent_node_id = ?,
+               tool = ?,
+               summary = ?,
+               files_touched = ?,
+               node_type = ?,
+               sync_hlc = ?,
+               sync_origin_device = ?,
+               sync_is_tombstone = ?,
+               sync_version = sync_version + 1
+           WHERE id = ?
+           RETURNING *`)
+                .get(lineageId, parentNodeId, tool, summary, filesTouched, nodeType, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone, existing.id);
+        }
+        return this.getPreparedStatement(`INSERT INTO nodes (lineage_id, parent_node_id, tool, summary, files_touched, node_type, created_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+         RETURNING *`)
+            .get(lineageId, parentNodeId, tool, summary, filesTouched, nodeType, createdAt, meta.syncUuid, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone);
+    }
+    upsertSyncTodo(projectId, lineageId, originNodeId, text, done, createdAt, doneAt, meta) {
+        const existing = this.getPreparedStatement('SELECT * FROM todos WHERE sync_uuid = ?').get(meta.syncUuid);
+        if (existing) {
+            return this.getPreparedStatement(`UPDATE todos
+           SET lineage_id = ?,
+               origin_node_id = ?,
+               text = ?,
+               done = ?,
+               done_at = ?,
+               sync_hlc = ?,
+               sync_origin_device = ?,
+               sync_is_tombstone = ?,
+               sync_version = sync_version + 1
+           WHERE id = ?
+           RETURNING *`)
+                .get(lineageId, originNodeId, text, done, doneAt, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone, existing.id);
+        }
+        return this.getPreparedStatement(`INSERT INTO todos (project_id, lineage_id, origin_node_id, text, done, created_at, done_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+         RETURNING *`)
+            .get(projectId, lineageId, originNodeId, text, done, createdAt, doneAt, meta.syncUuid, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone);
+    }
+    upsertSyncKnowledge(projectId, category, fact, why, originNodeId, supersedesId, status, createdAt, lastReferencedAt, legacyReferenceCount, conflictedAt, conflictedReason, resolvedAt, resolvedBy, resolutionKnowledgeId, meta) {
+        const existing = this.getPreparedStatement('SELECT * FROM knowledge WHERE sync_uuid = ?').get(meta.syncUuid);
+        if (existing) {
+            return this.getPreparedStatement(`UPDATE knowledge
+           SET category = ?,
+               fact = ?,
+               why = ?,
+               origin_node_id = ?,
+               supersedes_id = ?,
+               status = ?,
+               last_referenced_at = ?,
+               legacy_reference_count = ?,
+               conflicted_at = ?,
+               conflicted_reason = ?,
+               resolved_at = ?,
+               resolved_by = ?,
+               resolution_knowledge_id = ?,
+               sync_hlc = ?,
+               sync_origin_device = ?,
+               sync_is_tombstone = ?,
+               sync_version = sync_version + 1
+           WHERE id = ?
+           RETURNING *`)
+                .get(category, fact, why, originNodeId, supersedesId, status, lastReferencedAt, legacyReferenceCount, conflictedAt, conflictedReason, resolvedAt, resolvedBy, resolutionKnowledgeId, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone, existing.id);
+        }
+        return this.getPreparedStatement(`INSERT INTO knowledge (project_id, category, fact, why, origin_node_id, supersedes_id, status, created_at, last_referenced_at, legacy_reference_count, conflicted_at, conflicted_reason, resolved_at, resolved_by, resolution_knowledge_id, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+         RETURNING *`)
+            .get(projectId, category, fact, why, originNodeId, supersedesId, status, createdAt, lastReferencedAt, legacyReferenceCount, conflictedAt, conflictedReason, resolvedAt, resolvedBy, resolutionKnowledgeId, meta.syncUuid, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone);
+    }
+    upsertSyncConfirmation(knowledgeId, originNodeId, tool, confirmedAt, meta) {
+        const existing = this.getPreparedStatement('SELECT * FROM knowledge_confirmations WHERE sync_uuid = ?').get(meta.syncUuid);
+        if (existing) {
+            return this.getPreparedStatement(`UPDATE knowledge_confirmations
+           SET knowledge_id = ?,
+               origin_node_id = ?,
+               tool = ?,
+               confirmed_at = ?,
+               sync_hlc = ?,
+               sync_origin_device = ?,
+               sync_is_tombstone = ?,
+               sync_version = sync_version + 1
+           WHERE id = ?
+           RETURNING *`)
+                .get(knowledgeId, originNodeId, tool, confirmedAt, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone, existing.id);
+        }
+        return this.getPreparedStatement(`INSERT INTO knowledge_confirmations (knowledge_id, origin_node_id, tool, confirmed_at, sync_uuid, sync_hlc, sync_origin_device, sync_is_tombstone, sync_version)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1)
+         RETURNING *`)
+            .get(knowledgeId, originNodeId, tool, confirmedAt, meta.syncUuid, meta.syncHlc, meta.syncOriginDevice, meta.isTombstone);
+    }
+    markTombstoneBySyncUuid(table, syncUuid, syncHlc, syncOriginDevice) {
+        assertValidSyncTable(table);
+        const stmt = this.db.prepare(`
+      UPDATE ${table}
+      SET sync_is_tombstone = 1, sync_hlc = ?, sync_origin_device = ?, sync_version = sync_version + 1
+      WHERE sync_uuid = ?
+    `);
+        stmt.run(syncHlc, syncOriginDevice, syncUuid);
+    }
+}
+//# sourceMappingURL=store.js.map