@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/sync/syncService.js

@@ -15,6 +15,14 @@ function resolveWorkspaceAccessConflictMessage(data, fallbackStatus) {
     }
     return rawError || `Workspace provisioning failed (${fallbackStatus})`;
 }
+function isMissingCloudWorkspaceSelection(data, status) {
+    if (status !== 400)
+        return false;
+    const code = String(data.code || '').trim().toUpperCase();
+    const rawError = String(data.error || '').trim().toLowerCase();
+    return code === 'WORKSPACE_ID_REQUIRED'
+        && rawError.includes('no cloud workspace is selected');
+}
 export async function ensureCloudWorkspaceReadyForSyncService(input) {
     if (!input.cloudAuthConfigured)
         return { success: false, error: 'Cloud auth endpoint is not configured.' };
@@ -44,6 +52,39 @@ export async function ensureCloudWorkspaceReadyForSyncService(input) {
                 error: String(data.error || 'Workspace sync rate limited. Please retry later.')
             };
         }
+        if (isMissingCloudWorkspaceSelection(data, handshakeResult.status)) {
+            const provisionResult = await provisionWorkspace(input.resolveCloudAuthUrl, {
+                workspaceId: input.workspaceId,
+                name: input.workspaceName || input.workspaceId
+            });
+            if (!provisionResult.ok) {
+                const provisionError = asObjectRecord(provisionResult.data);
+                return {
+                    success: false,
+                    statusCode: provisionResult.status,
+                    transient: isTransientWorkspaceSyncStatus(provisionResult.status),
+                    retryAfterMs: provisionResult.retryAfterMs,
+                    error: resolveWorkspaceAccessConflictMessage(provisionError, provisionResult.status)
+                };
+            }
+            handshakeResult = await handshakeWorkspace(input.resolveCloudAuthUrl, input.workspaceId);
+            if (!handshakeResult.ok) {
+                const retryData = asObjectRecord(handshakeResult.data);
+                if (handshakeResult.status === 401) {
+                    return { success: false, statusCode: 401, transient: false, error: String(retryData.error || 'Authentication required for workspace sync.') };
+                }
+                if (handshakeResult.status === 429) {
+                    return { success: false, statusCode: 429, retryAfterMs: handshakeResult.retryAfterMs, transient: true, error: String(retryData.error || 'Workspace sync rate limited. Please retry later.') };
+                }
+                return {
+                    success: false,
+                    statusCode: handshakeResult.status,
+                    transient: isTransientWorkspaceSyncStatus(handshakeResult.status),
+                    error: String(retryData.error || `Workspace sync handshake failed (${handshakeResult.status})`)
+                };
+            }
+            return { success: true, provisioned: true };
+        }
         if (handshakeResult.status === 409 && data.code === 'WORKSPACE_ID_MISMATCH') {
             if (input.allowProvisionOnMismatch === false) {
                 return {
@@ -173,6 +214,8 @@ export async function runWorkspacePushSyncService(input) {
             changeCount,
             deleteCount,
             currentTaskIds: input.payload.currentTaskIds,
+            currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
+            currentTaskChangeKeys: input.payload.currentTaskChangeKeys ?? new Map(),
             deleteTaskIds: input.payload.deleteTaskIds,
             currentInitiativeIds: input.payload.currentInitiativeIds,
             currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
@@ -180,6 +223,7 @@ export async function runWorkspacePushSyncService(input) {
             currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
             currentAiProfileIds: input.payload.currentAiProfileIds,
             currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
+            currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
             currentDocumentPaths: input.payload.currentDocumentPaths,
             deleteDocumentPaths: input.payload.deleteDocumentPaths,
             currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
@@ -197,6 +241,7 @@ export async function runWorkspacePushSyncService(input) {
             currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
             currentTaskEventWatermarks: input.payload.currentTaskEventWatermarks,
             pushedWatermarks: new Map(),
+            pushedTaskChangeKeys: new Map(),
             emittedEventIds: [],
             appliedTaskUpserts: []
         };
@@ -231,6 +276,8 @@ export async function runWorkspacePushSyncService(input) {
         changeCount,
         deleteCount,
         currentTaskIds: input.payload.currentTaskIds,
+        currentTaskWatermarks: input.payload.currentTaskWatermarks ?? new Map(),
+        currentTaskChangeKeys: input.payload.currentTaskChangeKeys ?? new Map(),
         deleteTaskIds: input.payload.deleteTaskIds,
         currentInitiativeIds: input.payload.currentInitiativeIds,
         currentInitiativeWatermarks: input.payload.currentInitiativeWatermarks,
@@ -238,6 +285,7 @@ export async function runWorkspacePushSyncService(input) {
         currentWorkstreamWatermarks: input.payload.currentWorkstreamWatermarks,
         currentAiProfileIds: input.payload.currentAiProfileIds,
         currentAiProfileWatermarks: input.payload.currentAiProfileWatermarks,
+        currentAiProfileChangeKeys: input.payload.currentAiProfileChangeKeys ?? new Map(),
         currentDocumentPaths: input.payload.currentDocumentPaths,
         deleteDocumentPaths: input.payload.deleteDocumentPaths,
         currentDocumentWatermarks: input.payload.currentDocumentWatermarks,
@@ -255,6 +303,7 @@ export async function runWorkspacePushSyncService(input) {
         currentAnnotatedAttachmentSessionWatermarks: input.payload.currentAnnotatedAttachmentSessionWatermarks,
         currentTaskEventWatermarks: input.payload.currentTaskEventWatermarks,
         pushedWatermarks: input.payload.pushedWatermarks,
+        pushedTaskChangeKeys: input.payload.pushedTaskChangeKeys ?? new Map(),
         emittedEventIds,
         appliedTaskUpserts
     };
@@ -270,6 +319,7 @@ export async function runWorkspacePullSyncService(input) {
     let pulledActiveUpserts = false;
     let pulledArchivedUpserts = false;
     let pulledTaskEventUpserts = false;
+    let pulledPlanningUpserts = false;
     const documentDecryptFailures = new Set();
     const emittedEventIds = new Set();
     const pulledAnnotatedAttachmentSessionIds = new Set();
@@ -296,10 +346,13 @@ export async function runWorkspacePullSyncService(input) {
                 }
             }
             if (!pullRes.ok) {
+                const pullErrorData = asObjectRecord(pullRes.data);
                 return {
                     success: false,
                     kind: 'pull_http',
                     status: pullRes.status,
+                    errorCode: typeof pullErrorData.code === 'string' ? pullErrorData.code : undefined,
+                    error: typeof pullErrorData.error === 'string' ? pullErrorData.error : undefined,
                     retryAfterMs: pullRes.retryAfterMs,
                     transient: isTransientWorkspaceSyncStatus(pullRes.status),
                     cursor,
@@ -311,6 +364,7 @@ export async function runWorkspacePullSyncService(input) {
                     pulledActiveUpserts,
                     pulledArchivedUpserts,
                     pulledTaskEventUpserts,
+                    pulledPlanningUpserts,
                     documentDecryptFailures: Array.from(documentDecryptFailures),
                     serverDiagnostics: null
                 };
@@ -340,10 +394,14 @@ export async function runWorkspacePullSyncService(input) {
                         pulledAnnotatedAttachmentSessionIds.add(sessionId);
                     continue;
                 }
-                if (change.op === 'task-event-upsert') {
+                if (change.op === 'task-event-upsert' || change.op === 'entity-event-upsert') {
                     pulledTaskEventUpserts = true;
                     continue;
                 }
+                if (change.op === 'initiative-upsert' || change.op === 'workstream-upsert') {
+                    pulledPlanningUpserts = true;
+                    continue;
+                }
                 if (change.op === 'document-upsert') {
                     if (typeof change.content === 'string' && typeof process !== 'undefined' && process.env?.TASKFORCE_SYNC_KEY) {
                         try {
@@ -435,6 +493,7 @@ export async function runWorkspacePullSyncService(input) {
                         pulledActiveUpserts,
                         pulledArchivedUpserts,
                         pulledTaskEventUpserts,
+                        pulledPlanningUpserts,
                         documentDecryptFailures: Array.from(documentDecryptFailures),
                         emittedEventIds: Array.from(emittedEventIds),
                         serverDiagnostics: lastServerDiagnostics
@@ -457,6 +516,7 @@ export async function runWorkspacePullSyncService(input) {
                         pulledActiveUpserts,
                         pulledArchivedUpserts,
                         pulledTaskEventUpserts,
+                        pulledPlanningUpserts,
                         documentDecryptFailures: Array.from(documentDecryptFailures),
                         emittedEventIds: Array.from(emittedEventIds),
                         serverDiagnostics: lastServerDiagnostics
@@ -508,6 +568,7 @@ export async function runWorkspacePullSyncService(input) {
                         pulledActiveUpserts,
                         pulledArchivedUpserts,
                         pulledTaskEventUpserts,
+                        pulledPlanningUpserts,
                         documentDecryptFailures: Array.from(documentDecryptFailures),
                         emittedEventIds: Array.from(emittedEventIds),
                         serverDiagnostics: lastServerDiagnostics
@@ -537,6 +598,7 @@ export async function runWorkspacePullSyncService(input) {
                     pulledActiveUpserts,
                     pulledArchivedUpserts,
                     pulledTaskEventUpserts,
+                    pulledPlanningUpserts,
                     documentDecryptFailures: Array.from(documentDecryptFailures),
                     emittedEventIds: Array.from(emittedEventIds),
                     serverDiagnostics: lastServerDiagnostics
@@ -556,6 +618,7 @@ export async function runWorkspacePullSyncService(input) {
             pulledActiveUpserts,
             pulledArchivedUpserts,
             pulledTaskEventUpserts,
+            pulledPlanningUpserts,
             documentDecryptFailures: Array.from(documentDecryptFailures),
             emittedEventIds: Array.from(emittedEventIds),
             serverDiagnostics: lastServerDiagnostics
@@ -577,6 +640,7 @@ export async function runWorkspacePullSyncService(input) {
             pulledActiveUpserts,
             pulledArchivedUpserts,
             pulledTaskEventUpserts,
+            pulledPlanningUpserts,
             documentDecryptFailures: Array.from(documentDecryptFailures),
             emittedEventIds: Array.from(emittedEventIds),
             serverDiagnostics: null

package/dist/sync/syncService.test.js

@@ -443,7 +443,7 @@ describe('syncService', () => {
                 status: 200,
                 data: {
                     success: true,
-                    changes: [{ op: 'upsert', task: { id: 't-parent', title: 'Parent', status: 'done', updatedAt: '2026-03-15T20:27:08.000Z' } }],
+                    changes: [{ op: 'upsert', task: { id: 'task-apply-error', title: 'Apply error', status: 'done', updatedAt: '2026-03-15T20:27:08.000Z' } }],
                     nextCursor: null,
                     hasMore: false
                 }
@@ -452,7 +452,7 @@ describe('syncService', () => {
                 ok: false,
                 status: 400,
                 failures: ['/api/taskforce/sync/workspace/apply-local:400'],
-                data: { error: 'Parent tasks cannot be marked done manually; completion is derived from descendants' }
+                data: { error: 'Task apply rejected by local validation' }
             });
             const res = await runWorkspacePullSyncService({
                 resolveCloudAuthUrl: mockResolveCloudAuthUrl,
@@ -463,7 +463,7 @@ describe('syncService', () => {
             expect(res.success).toBe(false);
             expect(res.kind).toBe('apply_all_candidates');
             expect(res.status).toBe(400);
-            expect(res.error).toBe('Parent tasks cannot be marked done manually; completion is derived from descendants');
+            expect(res.error).toBe('Task apply rejected by local validation');
         });
         it('surfaces document decryption failures without failing pull', async () => {
             const previousKey = process.env.TASKFORCE_SYNC_KEY;
@@ -548,6 +548,45 @@ describe('syncService', () => {
             expect(res.pulledActiveUpserts).toBe(false);
             expect(res.pulledArchivedUpserts).toBe(false);
         });
+        it('marks planning upserts when the pull contains initiative or workstream changes', async () => {
+            vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: {
+                    success: true,
+                    changes: [{
+                            op: 'workstream-upsert',
+                            updatedAt: '2026-04-27T22:00:00.000Z',
+                            workstream: {
+                                id: 'ws-123',
+                                title: 'Planning sync workstream',
+                                description: 'Contains planning attachments',
+                                createdAt: '2026-04-27T21:00:00.000Z',
+                                updatedAt: '2026-04-27T22:00:00.000Z',
+                                attachments: []
+                            }
+                        }],
+                    nextCursor: null,
+                    hasMore: false
+                }
+            });
+            vi.mocked(applyLocalWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                failures: [],
+                appliedCount: 1,
+                data: { success: true }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false
+            });
+            expect(res.success).toBe(true);
+            expect(res.pulledPlanningUpserts).toBe(true);
+            expect(res.pulledActiveUpserts).toBe(false);
+            expect(res.pulledArchivedUpserts).toBe(false);
+        });
         it('zero-change bootstrap pull (no changes, hasMore false) returns success true', async () => {
             vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
                 ok: true,
@@ -702,6 +741,60 @@ describe('syncService', () => {
             expect(res.statusCode).toBe(0);
             expect(res.transient).toBe(true);
         });
+        it('recovers from missing cloud workspace selection by provisioning and retrying handshake', async () => {
+            vi.mocked(handshakeWorkspace)
+                .mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                data: {
+                    code: 'WORKSPACE_ID_REQUIRED',
+                    error: 'No cloud workspace is selected. Complete workspace setup first.'
+                }
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: {}
+            });
+            vi.mocked(provisionWorkspace).mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: {
+                    success: true,
+                    existing: true
+                }
+            });
+            const res = await ensureCloudWorkspaceReadyForSyncService(baseHandshakeInput);
+            expect(res.success).toBe(true);
+            expect(res.provisioned).toBe(true);
+            expect(provisionWorkspace).toHaveBeenCalledWith(mockResolveCloudAuthUrl, {
+                workspaceId: 'ws-test',
+                name: 'Test Workspace'
+            });
+            expect(handshakeWorkspace).toHaveBeenCalledTimes(2);
+        });
+        it('surfaces provisioning failure when recovering missing cloud workspace selection', async () => {
+            vi.mocked(handshakeWorkspace).mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                data: {
+                    code: 'WORKSPACE_ID_REQUIRED',
+                    error: 'No cloud workspace is selected. Complete workspace setup first.'
+                }
+            });
+            vi.mocked(provisionWorkspace).mockResolvedValueOnce({
+                ok: false,
+                status: 409,
+                data: {
+                    code: 'WORKSPACE_ID_ALREADY_EXISTS',
+                    error: 'Workspace ID already exists'
+                }
+            });
+            const res = await ensureCloudWorkspaceReadyForSyncService(baseHandshakeInput);
+            expect(res.success).toBe(false);
+            expect(res.statusCode).toBe(409);
+            expect(res.error).toContain('already linked to another cloud account');
+        });
         it('returns failure when cloudAuthConfigured is false', async () => {
             const res = await ensureCloudWorkspaceReadyForSyncService({
                 ...baseHandshakeInput,

package/dist/sync/taskSyncChangeKey.d.ts

@@ -0,0 +1,2 @@
+import type { TaskItem } from '../types.js';
+export declare function buildTaskSyncChangeKey(task: Partial<TaskItem> | null | undefined, archivedValue: boolean): string;

package/dist/sync/taskSyncChangeKey.js

@@ -0,0 +1,143 @@
+import { serializeTaskForSync } from './taskSyncPayload.js';
+import { normalizeSyncNullableId, normalizeSyncNullableIsoString, normalizeSyncNullableString, normalizeSyncOptionalId, normalizeSyncOptionalString, } from './syncFieldSemantics.js';
+function normalizeConflictTaxonomies(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const entries = Object.entries(value)
+        .filter(([key]) => String(key || '').trim().length > 0)
+        .sort(([left], [right]) => left.localeCompare(right));
+    const normalized = {};
+    for (const [key, raw] of entries) {
+        if (Array.isArray(raw)) {
+            normalized[key] = raw.map((entry) => String(entry ?? '')).sort((left, right) => left.localeCompare(right));
+            continue;
+        }
+        if (raw === undefined || raw === null)
+            continue;
+        normalized[key] = String(raw);
+    }
+    return normalized;
+}
+function normalizeConflictChecklistItems(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        const entry = item && typeof item === 'object' ? item : {};
+        return {
+            id: String(entry.id || '').trim(),
+            title: String(entry.title || '').trim(),
+            isCompleted: Boolean(entry.isCompleted),
+            order: entry.order === undefined || entry.order === null ? '' : String(entry.order),
+        };
+    })
+        .sort((left, right) => {
+        const leftOrder = Number.parseInt(left.order, 10);
+        const rightOrder = Number.parseInt(right.order, 10);
+        if (Number.isFinite(leftOrder) && Number.isFinite(rightOrder) && leftOrder !== rightOrder) {
+            return leftOrder - rightOrder;
+        }
+        if (left.title !== right.title)
+            return left.title.localeCompare(right.title);
+        return left.id.localeCompare(right.id);
+    });
+}
+function normalizeSyncComments(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((entry) => {
+        const comment = entry && typeof entry === 'object' ? entry : null;
+        return {
+            id: String(comment?.id || '').trim(),
+            author: String(comment?.author || '').trim(),
+            submittedAuthor: normalizeSyncOptionalString(comment?.submittedAuthor) || '',
+            text: String(comment?.text || ''),
+            timestamp: normalizeSyncNullableIsoString(comment?.timestamp) || '',
+            actor: comment?.actor ?? null,
+        };
+    })
+        .sort((left, right) => {
+        if (left.timestamp !== right.timestamp)
+            return left.timestamp.localeCompare(right.timestamp);
+        if (left.id !== right.id)
+            return left.id.localeCompare(right.id);
+        if (left.author !== right.author)
+            return left.author.localeCompare(right.author);
+        return left.text.localeCompare(right.text);
+    });
+}
+function normalizeSyncAttachments(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((entry) => {
+        if (typeof entry === 'string') {
+            const path = entry.trim();
+            return {
+                path,
+                fsPath: '',
+                caption: '',
+                displayName: '',
+                originalFilename: '',
+                assetId: '',
+                referenceNumber: '',
+                taskId: '',
+                timestamp: '',
+            };
+        }
+        const attachment = entry && typeof entry === 'object' ? entry : null;
+        return {
+            path: String(attachment?.path || '').trim(),
+            fsPath: normalizeSyncOptionalString(attachment?.fsPath) || '',
+            caption: normalizeSyncOptionalString(attachment?.caption) || '',
+            displayName: normalizeSyncOptionalString(attachment?.displayName) || '',
+            originalFilename: normalizeSyncOptionalString(attachment?.originalFilename) || '',
+            assetId: normalizeSyncOptionalId(attachment?.assetId) || '',
+            referenceNumber: attachment?.referenceNumber === undefined || attachment.referenceNumber === null
+                ? ''
+                : String(attachment.referenceNumber),
+            taskId: normalizeSyncNullableId(attachment?.taskId) || '',
+            timestamp: normalizeSyncNullableIsoString(attachment?.timestamp) || '',
+        };
+    })
+        .sort((left, right) => {
+        if (left.path !== right.path)
+            return left.path.localeCompare(right.path);
+        if (left.assetId !== right.assetId)
+            return left.assetId.localeCompare(right.assetId);
+        if (left.timestamp !== right.timestamp)
+            return left.timestamp.localeCompare(right.timestamp);
+        return JSON.stringify(left).localeCompare(JSON.stringify(right));
+    });
+}
+export function buildTaskSyncChangeKey(task, archivedValue) {
+    const source = serializeTaskForSync(task);
+    return JSON.stringify({
+        id: source.id,
+        title: source.title,
+        description: normalizeSyncNullableString(source.description) || '',
+        category: source.category,
+        type: source.type,
+        priority: source.priority === undefined || source.priority === null ? '' : String(source.priority),
+        complexity: source.complexity === undefined || source.complexity === null ? '' : String(source.complexity),
+        status: source.status,
+        approach: normalizeSyncOptionalString(source.approach) || '',
+        canceledReason: normalizeSyncNullableString(source.canceledReason) || '',
+        createdAt: source.createdAt,
+        completedAt: normalizeSyncNullableIsoString(source.completedAt) || '',
+        taxonomies: normalizeConflictTaxonomies(source.taxonomies),
+        createdBy: normalizeSyncOptionalId(source.createdBy) || '',
+        assignee: normalizeSyncOptionalId(source.assignee) || '',
+        scheduledDate: normalizeSyncNullableString(source.scheduledDate) || '',
+        dueDate: normalizeSyncNullableString(source.dueDate) || '',
+        scheduledWeekKey: normalizeSyncNullableString(source.scheduledWeekKey) || '',
+        orderInDay: source.orderInDay === undefined || source.orderInDay === null ? '' : String(source.orderInDay),
+        workstreamId: normalizeSyncNullableId(source.workstreamId) || '',
+        referenceNumber: source.referenceNumber === undefined || source.referenceNumber === null ? '' : String(source.referenceNumber),
+        comments: normalizeSyncComments(source.comments),
+        attachments: normalizeSyncAttachments(source.attachments),
+        checklistItems: normalizeConflictChecklistItems(source.checklistItems),
+        isArchived: archivedValue ? '1' : '0'
+    });
+}

package/dist/sync/taskSyncPayload.js

@@ -1,16 +1,11 @@
+import { normalizeSyncNullableString, normalizeSyncOptionalString, } from './syncFieldSemantics.js';
 function toOptionalString(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    const normalized = String(value).trim();
-    return normalized.length > 0 ? normalized : undefined;
+    return normalizeSyncOptionalString(value);
 }
 function toNullableString(value) {
     if (value === undefined)
         return undefined;
-    if (value === null)
-        return null;
-    const normalized = String(value).trim();
-    return normalized.length > 0 ? normalized : null;
+    return normalizeSyncNullableString(value);
 }
 function toOptionalBoolean(value) {
     return typeof value === 'boolean' ? value : undefined;

package/dist/sync/workspacePullFeed.d.ts

@@ -25,6 +25,10 @@ export interface WorkspacePullFeedResult {
         hydrationMs: number;
         encodeMs: number;
         buildMs: number;
+        snapshotErrors: Array<{
+            domain: string;
+            error: string;
+        }>;
     };
 }
 export declare function buildWorkspacePullFeed(input: {