@taskforcehq/taskforce 0.3.302 → 0.3.303

package/dist/server/routes/shared.js

@@ -167,9 +167,11 @@ export function makeEnsureAppAccess(core, context) {
             return true;
         const code = accountAccess.gate === 'plan_selection_required'
             ? 'PLAN_SELECTION_REQUIRED'
-            : accountAccess.gate === 'misconfigured'
-                ? 'ACCOUNT_ACCESS_MISCONFIGURED'
-                : 'ACCOUNT_ENTITLEMENT_REQUIRED';
+            : accountAccess.gate === 'checkout_pending'
+                ? 'CHECKOUT_PENDING'
+                : accountAccess.gate === 'misconfigured'
+                    ? 'ACCOUNT_ACCESS_MISCONFIGURED'
+                    : 'ACCOUNT_ENTITLEMENT_REQUIRED';
         res.writeHead(403, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
             error: accountAccess.message || 'This account cannot access the app.',

package/dist/server/routes/sync.integration.test.js

@@ -1311,6 +1311,166 @@ describe('Server Routes Workspace Sync Integration', () => {
             })
         ]);
     });
+    it('lets the cloud document ref win during normal sync apply and records a diagnostic', async () => {
+        const projectRoot = createIsolatedProjectRoot('taskforce-sync-apply-doc-ref-drift-');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId, name: 'Local Active Workspace' });
+        core.createTask({
+            id: 'task-doc-ref-drift-1',
+            title: 'Task with drifting synced markdown asset',
+            status: 'task'
+        }, {
+            workspaceId,
+            allowClientProvidedId: true
+        });
+        const seededStore = new WorkspaceAssetStore(core.getDatabaseAdapter(), core.getTenantId());
+        seededStore.upsertAsset({
+            assetId: 'asset-doc-ref-drift-1',
+            workspaceId,
+            kind: 'document',
+            originalFilename: 'phase1-ref-drift.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'docs/phase1-ref-drift.md',
+            contentSha256: 'sha-doc-ref-drift-local',
+            sizeBytes: 10,
+            documentId: 'doc-ref-drift-1',
+            referenceNumber: 12,
+            createdAt: '2026-03-17T11:55:00.000Z',
+            updatedAt: '2026-03-17T11:55:00.000Z'
+        });
+        seededStore.upsertLink({
+            workspaceId,
+            assetId: 'asset-doc-ref-drift-1',
+            taskId: 'task-doc-ref-drift-1',
+            role: 'attachment',
+            updatedAt: '2026-03-17T11:55:00.000Z',
+            deletedAt: null
+        });
+        const routes = createRoutes(core, { authConfig: { runtimeMode: 'local', enabled: false } });
+        const match = matchRoute('POST', '/api/taskforce/sync/workspace/apply-local', routes);
+        expect(match).toBeTruthy();
+        const req = createMockReq('POST', '/api/taskforce/sync/workspace/apply-local', {
+            changes: [
+                {
+                    op: 'document-upsert',
+                    path: 'docs/phase1-ref-drift.md',
+                    updatedAt: '2026-03-17T12:00:00.000Z',
+                    content: '# cloud canonical markdown\n',
+                    assetId: 'asset-doc-ref-drift-1',
+                    documentId: 'doc-ref-drift-1',
+                    referenceNumber: 18,
+                    version: 2,
+                    taskId: 'task-doc-ref-drift-1',
+                    originalFilename: 'phase1-ref-drift.md',
+                    linkRole: 'attachment'
+                }
+            ]
+        }, { 'x-taskforce-workspace-id': workspaceId });
+        const res = createMockRes();
+        await match?.handler(req, res, {});
+        expect(res.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const store = new WorkspaceAssetStore(reloadedCore.getDatabaseAdapter(), reloadedCore.getTenantId());
+        const asset = store.get('asset-doc-ref-drift-1', workspaceId);
+        const syncEvents = reloadedCore.listSyncEvents(workspaceId, 20);
+        expect(asset).toEqual(expect.objectContaining({
+            assetId: 'asset-doc-ref-drift-1',
+            referenceNumber: 18,
+            version: 2
+        }));
+        expect(syncEvents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                eventType: 'apply',
+                status: 'error',
+                errorMessage: 'Detected document reference number mismatch during normal sync.',
+                details: expect.objectContaining({
+                    assetId: 'asset-doc-ref-drift-1',
+                    existingReferenceNumber: 12,
+                    incomingReferenceNumber: 18
+                })
+            })
+        ]));
+    });
+    it('lets the cloud image ref win during normal sync apply and records a diagnostic', async () => {
+        const projectRoot = createIsolatedProjectRoot('taskforce-sync-apply-image-ref-drift-');
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId, name: 'Local Active Workspace' });
+        core.createTask({
+            id: 'task-image-ref-drift-1',
+            title: 'Task with drifting synced image asset',
+            status: 'task'
+        }, {
+            workspaceId,
+            allowClientProvidedId: true
+        });
+        const seededStore = new WorkspaceAssetStore(core.getDatabaseAdapter(), core.getTenantId());
+        seededStore.upsertAsset({
+            assetId: 'asset-image-ref-drift-1',
+            workspaceId,
+            kind: 'image',
+            originalFilename: 'hero.png',
+            mimeType: 'image/png',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-local-active/assets/images/hero.png',
+            contentSha256: 'sha-image-ref-drift-local',
+            sizeBytes: 10,
+            referenceNumber: 12,
+            createdAt: '2026-03-17T11:55:00.000Z',
+            updatedAt: '2026-03-17T11:55:00.000Z'
+        });
+        seededStore.upsertLink({
+            workspaceId,
+            assetId: 'asset-image-ref-drift-1',
+            taskId: 'task-image-ref-drift-1',
+            role: 'image',
+            updatedAt: '2026-03-17T11:55:00.000Z',
+            deletedAt: null
+        });
+        const routes = createRoutes(core, { authConfig: { runtimeMode: 'local', enabled: false } });
+        const match = matchRoute('POST', '/api/taskforce/sync/workspace/apply-local', routes);
+        expect(match).toBeTruthy();
+        const req = createMockReq('POST', '/api/taskforce/sync/workspace/apply-local', {
+            changes: [
+                {
+                    op: 'asset-upsert',
+                    path: 'workspaces/workspace-local-active/assets/images/hero.png',
+                    updatedAt: '2026-03-17T12:05:00.000Z',
+                    contentBase64: Buffer.from('cloud-hero').toString('base64'),
+                    assetId: 'asset-image-ref-drift-1',
+                    kind: 'image',
+                    mimeType: 'image/png',
+                    referenceNumber: 18,
+                    taskId: 'task-image-ref-drift-1',
+                    originalFilename: 'hero.png',
+                    linkRole: 'image'
+                }
+            ]
+        }, { 'x-taskforce-workspace-id': workspaceId });
+        const res = createMockRes();
+        await match?.handler(req, res, {});
+        expect(res.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const store = new WorkspaceAssetStore(reloadedCore.getDatabaseAdapter(), reloadedCore.getTenantId());
+        const asset = store.get('asset-image-ref-drift-1', workspaceId);
+        const syncEvents = reloadedCore.listSyncEvents(workspaceId, 20);
+        expect(asset).toEqual(expect.objectContaining({
+            assetId: 'asset-image-ref-drift-1',
+            referenceNumber: 18
+        }));
+        expect(syncEvents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                eventType: 'apply',
+                status: 'error',
+                errorMessage: 'Detected asset reference number mismatch during normal sync.',
+                details: expect.objectContaining({
+                    assetId: 'asset-image-ref-drift-1',
+                    existingReferenceNumber: 12,
+                    incomingReferenceNumber: 18
+                })
+            })
+        ]));
+    });
     it('round-trips cloud attachment links for canonical markdown and file assets into local apply', async () => {
         const cloudProjectRoot = createIsolatedProjectRoot('taskforce-sync-cloud-link-roundtrip-cloud-');
         const localProjectRoot = createIsolatedProjectRoot('taskforce-sync-cloud-link-roundtrip-local-');

package/dist/server/routes/sync.js

@@ -771,10 +771,18 @@ export function registerSyncRoutes(deps) {
                 })),
                 ...incomingDocuments
                     .map((doc) => serializeDocumentSyncPayload(doc))
-                    .filter((doc) => Boolean(doc && doc.path.length > 0)),
+                    .filter((doc) => Boolean(doc && doc.path.length > 0))
+                    .map((doc) => ({
+                    op: 'document-upsert',
+                    ...doc
+                })),
                 ...incomingAssets
                     .map((asset) => serializeBinaryAssetSyncPayload(asset))
-                    .filter((asset) => Boolean(asset && asset.path.length > 0 && asset.contentBase64.length > 0)),
+                    .filter((asset) => Boolean(asset && asset.path.length > 0 && asset.contentBase64.length > 0))
+                    .map((asset) => ({
+                    op: 'asset-upsert',
+                    ...asset
+                })),
                 ...incomingDocumentReviewSessions
                     .map((session) => normalizeDocumentReviewSessionSyncPayload(session))
                     .filter((session) => Boolean(session && session.id.length > 0 && session.assetId.length > 0))
@@ -1060,7 +1068,7 @@ export function registerSyncRoutes(deps) {
         const pageSize = Number.isFinite(requestedLimit) && requestedLimit > 0
             ? Math.max(1, Math.min(500, Math.floor(requestedLimit)))
             : 200;
-        const { workspaceMembers, changes, nextCursor, hasMore } = await buildWorkspacePullFeed({
+        const { workspaceMembers, changes, nextCursor, hasMore, diagnostics } = await buildWorkspacePullFeed({
             core,
             workspaceId: targetWorkspaceId,
             cursor,
@@ -1076,12 +1084,14 @@ export function registerSyncRoutes(deps) {
             workspaceMembers,
             changes,
             nextCursor,
-            hasMore
+            hasMore,
+            diagnostics
         }));
         auditAuthAction(req, 'sync-workspace-pull-success', {
             workspaceId: targetWorkspaceId,
             returnedChanges: changes.length,
-            hasMore
+            hasMore,
+            diagnostics
         });
     });
     // POST /api/taskforce/sync/workspace/apply-local - Apply pulled cloud deltas into local workspace store

package/dist/server/routes.js

@@ -345,7 +345,7 @@ export function createRoutes(core, context = {}) {
         const authSettings = globalSettings.auth || {};
         const authRateLimitMaxRequestsRaw = Number(authSettings.authRateLimitMaxRequests);
         const authRateLimitWindowMsRaw = Number(authSettings.authRateLimitWindowMs);
-        const signupSettings = core.getSignupMonetizationSettings();
+        const onboardingPolicy = core.getOnboardingPolicy();
         return {
             allowSelfRegistration: resolveBooleanSetting(authSettings.allowSelfRegistration, true),
             requireVerifiedEmail: resolveBooleanSetting(authSettings.requireVerifiedEmail, true),
@@ -357,8 +357,8 @@ export function createRoutes(core, context = {}) {
             authRateLimitWindowMs: Number.isFinite(authRateLimitWindowMsRaw) && authRateLimitWindowMsRaw >= 1000
                 ? Math.floor(authRateLimitWindowMsRaw)
                 : 15 * 60_000,
-            signupMonetizationStrategy: signupSettings.strategy,
-            defaultSignupPlanVersionId: signupSettings.defaultSignupPlanVersionId
+            onboardingPolicyMode: onboardingPolicy.mode,
+            onboardingPlanVersionId: onboardingPolicy.planVersionId
         };
     };
     const deliverAuthEmail = async (kind, email, token, req) => {