@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/core/SyncReconciliationService.js

@@ -1,5 +1,5 @@
-import { DEFAULT_TYPE_VALUE } from '../shared/taxonomyDefaults.js';
 import { buildTaskSyncChangeKey } from '../sync/taskSyncChangeKey.js';
+import { canonicalTaskNestedContent } from '../sync/taskNestedContent.js';
 export function listTasksForSyncService(deps, workspaceId, cursor, limit) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
     const safeLimit = Math.max(1, Math.min(10000, Math.floor(limit)));
@@ -39,39 +39,62 @@ export function listWorkspaceSyncDeletesSinceService(deps, workspaceId, cursor,
     let rows;
     if (cursor) {
         rows = deps.db.prepare(`
-            SELECT task_id, deleted_at
-            FROM workspace_sync_deletes
-            WHERE tenant_id = ?
-              AND workspace_id = ?
+            SELECT s.task_id, s.deleted_at, d.actor, d.actor_type, d.source, d.details_json
+            FROM workspace_sync_deletes s
+            LEFT JOIN deleted_tasks d ON d.tenant_id = s.tenant_id AND d.workspace_id = s.workspace_id AND d.task_id = s.task_id
+            WHERE s.tenant_id = ?
+              AND s.workspace_id = ?
               AND (
-                  deleted_at > ?
-                  OR (deleted_at = ? AND task_id > ?)
+                  s.deleted_at > ?
+                  OR (s.deleted_at = ? AND s.task_id > ?)
               )
-            ORDER BY deleted_at ASC, task_id ASC
+            ORDER BY s.deleted_at ASC, s.task_id ASC
             LIMIT ?
         `).all(deps.tenantId, normalizedWorkspaceId, cursor.watermark, cursor.watermark, cursor.id, safeLimit);
     }
     else {
         rows = deps.db.prepare(`
-            SELECT task_id, deleted_at
-            FROM workspace_sync_deletes
-            WHERE tenant_id = ?
-              AND workspace_id = ?
-            ORDER BY deleted_at ASC, task_id ASC
+            SELECT s.task_id, s.deleted_at, d.actor, d.actor_type, d.source, d.details_json
+            FROM workspace_sync_deletes s
+            LEFT JOIN deleted_tasks d ON d.tenant_id = s.tenant_id AND d.workspace_id = s.workspace_id AND d.task_id = s.task_id
+            WHERE s.tenant_id = ?
+              AND s.workspace_id = ?
+            ORDER BY s.deleted_at ASC, s.task_id ASC
             LIMIT ?
         `).all(deps.tenantId, normalizedWorkspaceId, safeLimit);
     }
     return rows
-        .map((row) => ({
-        taskId: String(row.task_id || '').trim(),
-        deletedAt: String(row.deleted_at || '').trim()
-    }))
+        .map((row) => {
+        let details;
+        try {
+            const parsed = row.details_json ? JSON.parse(String(row.details_json)) : null;
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                details = parsed;
+        }
+        catch {
+            details = undefined;
+        }
+        const actorType = row.actor_type === 'human' || row.actor_type === 'ai' || row.actor_type === 'system'
+            ? row.actor_type
+            : undefined;
+        const source = row.source === 'ui' || row.source === 'mcp' || row.source === 'sync' || row.source === 'workspace-delete' || row.source === 'system'
+            ? row.source
+            : undefined;
+        return {
+            taskId: String(row.task_id || '').trim(),
+            deletedAt: String(row.deleted_at || '').trim(),
+            ...(row.actor ? { actor: String(row.actor) } : {}),
+            ...(actorType ? { actorType } : {}),
+            ...(source ? { source } : {}),
+            ...(details ? { details } : {}),
+        };
+    })
         .filter((row) => row.taskId.length > 0 && Number.isFinite(Date.parse(row.deletedAt)));
 }
 function buildSyncConflictKey(task, archivedValue) {
     return buildTaskSyncChangeKey(task, archivedValue);
 }
-export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
+export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId, options) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
     const activeTasks = Array.isArray(input?.tasks) ? input.tasks : [];
     const archivedTasks = Array.isArray(input?.archived) ? input.archived : [];
@@ -96,6 +119,7 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
     let archived = 0;
     let unarchived = 0;
     let skipped = 0;
+    const changedTaskIds = new Set();
     for (const item of combined) {
         const sourceTask = (item.task && typeof item.task === 'object') ? item.task : {};
         const taskId = String(sourceTask.id || '').trim();
@@ -115,16 +139,16 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
         const normalizedIncomingStatus = incomingStatus === undefined
             ? undefined
             : deps.normalizeStatusValue(incomingStatus);
-        const taskPatch = {
+        const incomingType = typeof sourceTask.type === 'string' ? sourceTask.type.trim() : sourceTask.type;
+        let taskPatch = {
             id: taskId,
             title: String(sourceTask.title || existing?.title || 'Untitled Task'),
             description: sourceTask.description === undefined ? existing?.description || null : (sourceTask.description || null),
             category: String(sourceTask.category || existing?.category || deps.defaultCategoryValue),
-            type: String(sourceTask.type || existing?.type || DEFAULT_TYPE_VALUE),
+            type: incomingType ? String(incomingType) : existing?.type,
             priority: sourceTask.priority === undefined ? existing?.priority : sourceTask.priority,
             complexity: sourceTask.complexity === undefined ? existing?.complexity : sourceTask.complexity,
             status: normalizedIncomingStatus || existing?.status || 'task',
-            approach: sourceTask.approach === undefined ? existing?.approach : sourceTask.approach,
             canceledReason: sourceTask.canceledReason === undefined ? existing?.canceledReason : sourceTask.canceledReason,
             createdAt: String(sourceTask.createdAt || existing?.createdAt || new Date().toISOString()),
             updatedAt: incomingUpdatedAt || existing?.updatedAt || undefined,
@@ -144,20 +168,57 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
             attachments: sourceTask.attachments === undefined ? undefined : sourceTask.attachments,
             checklistItems: sourceTask.checklistItems === undefined ? undefined : sourceTask.checklistItems
         };
-        if (existing
-            && Number.isFinite(incomingMs)
-            && Number.isFinite(existingMs)) {
-            if (incomingMs < existingMs) {
+        let syncUpdatedAt = incomingUpdatedAt;
+        let applyLegacyLifecycle = true;
+        if (existing && options?.authoritativeTaskNestedContentIds?.has(taskId)) {
+            const incomingNestedContent = {
+                id: taskId,
+                comments: taskPatch.comments,
+                attachments: taskPatch.attachments,
+                checklistItems: taskPatch.checklistItems,
+            };
+            const existingNestedContent = {
+                id: taskId,
+                comments: existing.comments,
+                attachments: existing.attachments,
+                checklistItems: existing.checklistItems,
+            };
+            if (canonicalTaskNestedContent(incomingNestedContent) === canonicalTaskNestedContent(existingNestedContent)) {
                 skipped++;
                 continue;
             }
-            if (incomingMs === existingMs) {
+            taskPatch = incomingNestedContent;
+            syncUpdatedAt = existingUpdatedAt;
+            applyLegacyLifecycle = false;
+        }
+        else if (existing
+            && Number.isFinite(incomingMs)
+            && Number.isFinite(existingMs)) {
+            let incomingLosesLegacyOrdering = incomingMs < existingMs;
+            if (!incomingLosesLegacyOrdering && incomingMs === existingMs) {
                 const incomingConflictKey = buildSyncConflictKey(taskPatch, desiredArchived);
                 const existingConflictKey = buildSyncConflictKey(existing, Boolean(existing?.isArchived));
-                if (incomingConflictKey.localeCompare(existingConflictKey) <= 0) {
+                incomingLosesLegacyOrdering = incomingConflictKey.localeCompare(existingConflictKey) <= 0;
+            }
+            if (incomingLosesLegacyOrdering) {
+                if (!options?.authoritativeTaskTaxonomyIds?.has(taskId)) {
+                    skipped++;
+                    continue;
+                }
+                const taxonomyPatch = { id: taskId };
+                if (taskPatch.category !== existing.category)
+                    taxonomyPatch.category = taskPatch.category;
+                if (taskPatch.type !== existing.type)
+                    taxonomyPatch.type = taskPatch.type;
+                if (taskPatch.priority !== existing.priority)
+                    taxonomyPatch.priority = taskPatch.priority;
+                if (Object.keys(taxonomyPatch).length === 1) {
                     skipped++;
                     continue;
                 }
+                taskPatch = taxonomyPatch;
+                syncUpdatedAt = existingUpdatedAt;
+                applyLegacyLifecycle = false;
             }
         }
         if (!existing) {
@@ -168,10 +229,12 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
                     allowClientProvidedId: true,
                     preferIncomingReferenceNumberOnConflict: true,
                     skipRecompute: true,
-                    syncUpdatedAt: incomingUpdatedAt,
-                    skipTaskEvents: true
+                    syncUpdatedAt,
+                    skipTaskEvents: true,
+                    ...(options?.deferSideEffects ? { emitRealtime: false } : {})
                 });
                 created++;
+                changedTaskIds.add(taskId);
             }
             catch {
                 skipped++;
@@ -185,8 +248,12 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
                     persistBackup: false,
                     preferIncomingReferenceNumberOnConflict: true,
                     skipRecompute: true,
-                    syncUpdatedAt: incomingUpdatedAt,
-                    skipTaskEvents: true
+                    syncUpdatedAt,
+                    skipTaskEvents: true,
+                    ...(options?.deferSideEffects ? { emitRealtime: false } : {}),
+                    ...(options?.authoritativeTaskNestedContentIds?.has(taskId)
+                        ? { allowArchivedNestedContentSyncWrite: true }
+                        : {}),
                 });
             }
             catch {
@@ -198,17 +265,19 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
                 continue;
             }
             updated++;
+            changedTaskIds.add(taskId);
         }
         const next = deps.getTask(taskId, normalizedWorkspaceId);
-        if (desiredArchived && next && !next.isArchived) {
+        if (applyLegacyLifecycle && desiredArchived && next && !next.isArchived) {
             const cancel = String(sourceTask.status || '').trim() === 'cancelled';
             try {
-                const archivedTask = deps.archiveTask(taskId, cancel, sourceTask.canceledReason, normalizedWorkspaceId, {
+                const archivedTask = deps.archiveTask(taskId, cancel, sourceTask.canceledReason || undefined, normalizedWorkspaceId, {
                     persistBackup: false,
                     skipRecompute: true,
                     syncUpdatedAt: incomingUpdatedAt,
                     skipHierarchyCheck: true,
-                    skipTaskEvents: true
+                    skipTaskEvents: true,
+                    ...(options?.deferSideEffects ? { emitRealtime: false } : {})
                 });
                 if (archivedTask)
                     archived++;
@@ -217,13 +286,14 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
                 skipped++;
             }
         }
-        else if (!desiredArchived && next && next.isArchived) {
+        else if (applyLegacyLifecycle && !desiredArchived && next && next.isArchived) {
             try {
                 const restored = deps.unarchiveTask(taskId, normalizedWorkspaceId, {
                     persistBackup: false,
                     skipRecompute: true,
                     syncUpdatedAt: incomingUpdatedAt,
-                    skipTaskEvents: true
+                    skipTaskEvents: true,
+                    ...(options?.deferSideEffects ? { emitRealtime: false } : {})
                 });
                 if (restored)
                     unarchived++;
@@ -233,14 +303,16 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
             }
         }
     }
-    deps.persistBackup();
+    if (!options?.deferSideEffects)
+        deps.persistBackup();
     return {
         total: combined.length,
         created,
         updated,
         archived,
         unarchived,
-        skipped
+        skipped,
+        ...(options?.deferSideEffects ? { changedTaskIds: Array.from(changedTaskIds).sort() } : {})
     };
 }
 export function readPushIdempotencyService(deps, workspaceId, idempotencyKey) {
@@ -258,9 +330,97 @@ export function readPushIdempotencyService(deps, workspaceId, idempotencyKey) {
     `).get(deps.tenantId, normalizedWorkspaceId, idempotencyKey, now);
     return typeof row?.payload === 'string' ? row.payload : null;
 }
+export function claimPushIdempotencyService(deps, workspaceId, idempotencyKey, claimToken, leaseMs = 15 * 60_000) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const now = Date.now();
+    const expiresAt = now + Math.max(60_000, Math.floor(leaseMs));
+    const claimPayload = JSON.stringify({ state: 'in-progress', claimToken, claimedAt: now });
+    deps.db.prepare(`DELETE FROM sync_idempotency WHERE expires_at <= ?`).run(now);
+    deps.db.prepare(`
+        INSERT INTO sync_idempotency (tenant_id, workspace_id, idempotency_key, payload, expires_at)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT (tenant_id, workspace_id, idempotency_key) DO NOTHING
+    `).run(deps.tenantId, normalizedWorkspaceId, idempotencyKey, claimPayload, expiresAt);
+    const row = deps.db.prepare(`
+        SELECT payload, expires_at
+        FROM sync_idempotency
+        WHERE tenant_id = ? AND workspace_id = ? AND idempotency_key = ? AND expires_at > ?
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, idempotencyKey, now);
+    const payload = typeof row?.payload === 'string' ? row.payload : '';
+    if (payload === claimPayload)
+        return { status: 'acquired' };
+    try {
+        const parsed = JSON.parse(payload);
+        if (parsed?.state === 'in-progress') {
+            return {
+                status: 'in-progress',
+                retryAfterMs: Math.max(1_000, Number(row?.expires_at || expiresAt) - now)
+            };
+        }
+    }
+    catch {
+        // Completed payloads are ordinary serialized route responses.
+    }
+    return { status: 'completed', payload };
+}
+function readOwnedPushIdempotencyClaimPayload(deps, workspaceId, idempotencyKey, claimToken) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const row = deps.db.prepare(`
+        SELECT payload, expires_at
+        FROM sync_idempotency
+        WHERE tenant_id = ? AND workspace_id = ? AND idempotency_key = ?
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, idempotencyKey);
+    const payload = String(row?.payload || '');
+    try {
+        const parsed = JSON.parse(payload);
+        if (parsed?.state !== 'in-progress' || parsed.claimToken !== claimToken)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return { normalizedWorkspaceId, payload, expiresAt: Number(row?.expires_at || 0) };
+}
+export function renewPushIdempotencyClaimService(deps, workspaceId, idempotencyKey, claimToken, leaseMs = 15 * 60_000) {
+    const owned = readOwnedPushIdempotencyClaimPayload(deps, workspaceId, idempotencyKey, claimToken);
+    const now = Date.now();
+    if (!owned || owned.expiresAt <= now)
+        return false;
+    const expiresAt = now + Math.max(60_000, Math.floor(leaseMs));
+    deps.db.prepare(`
+        UPDATE sync_idempotency
+        SET expires_at = ?
+        WHERE tenant_id = ? AND workspace_id = ? AND idempotency_key = ? AND payload = ? AND expires_at > ?
+    `).run(expiresAt, deps.tenantId, owned.normalizedWorkspaceId, idempotencyKey, owned.payload, now);
+    return Boolean(readOwnedPushIdempotencyClaimPayload(deps, workspaceId, idempotencyKey, claimToken));
+}
+export function completePushIdempotencyClaimService(deps, workspaceId, idempotencyKey, claimToken, payload) {
+    const owned = readOwnedPushIdempotencyClaimPayload(deps, workspaceId, idempotencyKey, claimToken);
+    const now = Date.now();
+    if (!owned || owned.expiresAt <= now)
+        return false;
+    const expiresAt = Date.now() + 24 * 60 * 60_000;
+    deps.db.prepare(`
+        UPDATE sync_idempotency
+        SET payload = ?, expires_at = ?
+        WHERE tenant_id = ? AND workspace_id = ? AND idempotency_key = ? AND payload = ? AND expires_at > ?
+    `).run(payload, expiresAt, deps.tenantId, owned.normalizedWorkspaceId, idempotencyKey, owned.payload, now);
+    return readPushIdempotencyService(deps, workspaceId, idempotencyKey) === payload;
+}
+export function releasePushIdempotencyClaimService(deps, workspaceId, idempotencyKey, claimToken) {
+    const owned = readOwnedPushIdempotencyClaimPayload(deps, workspaceId, idempotencyKey, claimToken);
+    if (!owned)
+        return;
+    deps.db.prepare(`
+        DELETE FROM sync_idempotency
+        WHERE tenant_id = ? AND workspace_id = ? AND idempotency_key = ? AND payload = ?
+    `).run(deps.tenantId, owned.normalizedWorkspaceId, idempotencyKey, owned.payload);
+}
 export function writePushIdempotencyService(deps, workspaceId, idempotencyKey, payload) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
-    const expiresAt = Date.now() + 10 * 60_000;
+    const expiresAt = Date.now() + 24 * 60 * 60_000;
     deps.db.prepare(`
         INSERT INTO sync_idempotency (tenant_id, workspace_id, idempotency_key, payload, expires_at)
         VALUES (?, ?, ?, ?, ?)
@@ -269,28 +429,34 @@ export function writePushIdempotencyService(deps, workspaceId, idempotencyKey, p
             expires_at = excluded.expires_at
     `).run(deps.tenantId, normalizedWorkspaceId, idempotencyKey, payload, expiresAt);
 }
-export function recordSyncEventService(deps, workspaceId, event) {
+function appendSyncEventService(deps, workspaceId, event) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    deps.db.prepare(`
+        INSERT INTO sync_events
+            (tenant_id, workspace_id, event_type, status, status_code, error_message, change_count, request_ms, details_json, occurred_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(deps.tenantId, normalizedWorkspaceId, event.eventType, event.status, event.statusCode ?? null, event.errorMessage ?? null, event.changeCount ?? null, event.requestMs ?? null, event.details ? JSON.stringify(event.details) : null, new Date().toISOString());
+    deps.db.prepare(`
+        DELETE FROM sync_events
+        WHERE tenant_id = ? AND workspace_id = ? AND id NOT IN (
+            SELECT id FROM sync_events
+            WHERE tenant_id = ? AND workspace_id = ?
+            ORDER BY id DESC
+            LIMIT 1000
+        )
+    `).run(deps.tenantId, normalizedWorkspaceId, deps.tenantId, normalizedWorkspaceId);
+}
+export function recordSyncEventService(deps, workspaceId, event) {
     try {
-        deps.db.prepare(`
-            INSERT INTO sync_events
-                (tenant_id, workspace_id, event_type, status, status_code, error_message, change_count, request_ms, details_json, occurred_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(deps.tenantId, normalizedWorkspaceId, event.eventType, event.status, event.statusCode ?? null, event.errorMessage ?? null, event.changeCount ?? null, event.requestMs ?? null, event.details ? JSON.stringify(event.details) : null, new Date().toISOString());
-        deps.db.prepare(`
-            DELETE FROM sync_events
-            WHERE tenant_id = ? AND workspace_id = ? AND id NOT IN (
-                SELECT id FROM sync_events
-                WHERE tenant_id = ? AND workspace_id = ?
-                ORDER BY id DESC
-                LIMIT 1000
-            )
-        `).run(deps.tenantId, normalizedWorkspaceId, deps.tenantId, normalizedWorkspaceId);
+        appendSyncEventService(deps, workspaceId, event);
     }
     catch {
         // best-effort
     }
 }
+export function recordSyncEventDurablyService(deps, workspaceId, event) {
+    appendSyncEventService(deps, workspaceId, event);
+}
 export function getDocumentWatermarkService(deps, workspaceId, docPath) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
     const row = deps.db.prepare(`
@@ -301,46 +467,52 @@ export function getDocumentWatermarkService(deps, workspaceId, docPath) {
     return row ? { updatedAt: row.updated_at, contentHash: row.content_hash } : null;
 }
 export function upsertDocumentWatermarkService(deps, workspaceId, docPath, contentHash, updatedAt) {
-    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
     try {
-        const existing = getDocumentWatermarkService(deps, normalizedWorkspaceId, docPath);
-        if (existing && existing.contentHash === contentHash)
-            return;
-        deps.db.prepare(`
-            INSERT INTO workspace_documents (tenant_id, workspace_id, path, content_hash, updated_at)
-            VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT (tenant_id, workspace_id, path) DO UPDATE SET
-                content_hash = excluded.content_hash,
-                updated_at   = excluded.updated_at
-        `).run(deps.tenantId, normalizedWorkspaceId, docPath, contentHash, updatedAt);
-        deps.emitRealtimeMutation({
-            workspaceId: normalizedWorkspaceId,
-            entityType: 'document-metadata',
-            changeType: 'upsert',
-            entityIds: [docPath]
-        });
+        upsertDocumentWatermarkStrictService(deps, workspaceId, docPath, contentHash, updatedAt);
     }
     catch {
         // best-effort
     }
 }
-export function deleteDocumentWatermarkService(deps, workspaceId, docPath) {
+export function upsertDocumentWatermarkStrictService(deps, workspaceId, docPath, contentHash, updatedAt) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const existing = getDocumentWatermarkService(deps, normalizedWorkspaceId, docPath);
+    if (existing && existing.contentHash === contentHash)
+        return;
+    deps.db.prepare(`
+        INSERT INTO workspace_documents (tenant_id, workspace_id, path, content_hash, updated_at)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT (tenant_id, workspace_id, path) DO UPDATE SET
+            content_hash = excluded.content_hash,
+            updated_at   = excluded.updated_at
+    `).run(deps.tenantId, normalizedWorkspaceId, docPath, contentHash, updatedAt);
+    deps.emitRealtimeMutation({
+        workspaceId: normalizedWorkspaceId,
+        entityType: 'document-metadata',
+        changeType: 'upsert',
+        entityIds: [docPath]
+    });
+}
+export function deleteDocumentWatermarkService(deps, workspaceId, docPath) {
     try {
-        const result = deps.db.prepare(`
-            DELETE FROM workspace_documents
-            WHERE tenant_id = ? AND workspace_id = ? AND path = ?
-        `).run(deps.tenantId, normalizedWorkspaceId, docPath);
-        if (Number(result?.changes || 0) > 0) {
-            deps.emitRealtimeMutation({
-                workspaceId: normalizedWorkspaceId,
-                entityType: 'document-metadata',
-                changeType: 'delete',
-                entityIds: [docPath]
-            });
-        }
+        deleteDocumentWatermarkStrictService(deps, workspaceId, docPath);
     }
     catch {
         // best-effort
     }
 }
+export function deleteDocumentWatermarkStrictService(deps, workspaceId, docPath) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const result = deps.db.prepare(`
+        DELETE FROM workspace_documents
+        WHERE tenant_id = ? AND workspace_id = ? AND path = ?
+    `).run(deps.tenantId, normalizedWorkspaceId, docPath);
+    if (Number(result?.changes || 0) > 0) {
+        deps.emitRealtimeMutation({
+            workspaceId: normalizedWorkspaceId,
+            entityType: 'document-metadata',
+            changeType: 'delete',
+            entityIds: [docPath]
+        });
+    }
+}

package/dist/core/TaskActivityService.d.ts

@@ -8,9 +8,17 @@ export interface TaskActivityServiceDeps {
     normalizeWorkspaceId: (workspaceId: string | undefined) => string;
     resolveWorkspaceActor: (workspaceId: string, actorRef: unknown) => TaskActor | null;
 }
+export declare class EntityEventIdentityCollisionError extends Error {
+    readonly code = "ENTITY_EVENT_IDENTITY_COLLISION";
+    readonly statusCode = 409;
+    constructor(eventId: string, mismatchedFields?: string[]);
+}
 export declare function listWorkspaceTaskEventsService(deps: TaskActivityServiceDeps, workspaceId: string): TaskEvent[];
 export declare function listWorkspaceEntityEventsService(deps: TaskActivityServiceDeps, workspaceId: string): EntityEvent[];
-export declare function listWorkspaceEntityEventsForSyncService(deps: TaskActivityServiceDeps, workspaceId: string): EntityEvent[];
+export declare function listWorkspaceEntityEventsForSyncService(deps: TaskActivityServiceDeps, workspaceId: string, cursor?: {
+    watermark: string;
+    id: string;
+} | null, limit?: number): EntityEvent[];
 export declare function listWorkspaceTaskEventsForSyncService(deps: TaskActivityServiceDeps, workspaceId: string): TaskEvent[];
 export declare function getTaskEventForSyncService(deps: TaskActivityServiceDeps, input: {
     taskId: string;
@@ -34,18 +42,30 @@ export declare function addEntityEventService(deps: TaskActivityServiceDeps, inp
     workspaceId: string;
     action: string;
     actor: unknown;
+    eventId?: string;
     createdAt?: string;
     details?: TaskEventDetails;
+    allowAuthoritativeReplacement?: boolean;
 }): void;
 export declare function addTaskEventService(deps: TaskActivityServiceDeps, input: {
     taskId: string;
     workspaceId: string;
     action: string;
     actor: unknown;
+    eventId?: string;
     createdAt?: string;
     details?: TaskEventDetails;
+    allowAuthoritativeReplacement?: boolean;
 }): void;
 export declare function replaceEntityEventsService(deps: TaskActivityServiceDeps, entityType: ActivityEntityType, entityId: string, workspaceId: string, entityEvents: EntityEvent[]): void;
 export declare function replaceTaskEventsService(deps: TaskActivityServiceDeps, taskId: string, workspaceId: string, taskEvents: TaskEvent[]): void;
-export declare function upsertEntityEventForSyncService(deps: TaskActivityServiceDeps, event: EntityEvent): EntityEvent;
+export declare function upsertEntityEventForSyncService(deps: TaskActivityServiceDeps, event: EntityEvent, options?: {
+    allowAuthoritativeReplacement?: boolean;
+}): EntityEvent;
+export declare function deleteEntityEventForSyncService(deps: TaskActivityServiceDeps, input: {
+    workspaceId: string;
+    eventId: string;
+    entityType: string;
+    entityId: string;
+}): boolean;
 export declare function upsertTaskEventForSyncService(deps: TaskActivityServiceDeps, event: TaskEvent): TaskEvent;