@taskforcehq/taskforce 0.3.306 → 0.3.308

package/dist/server/routes/billing.test.js

@@ -157,6 +157,7 @@ function setupBillingSchema(db) {
             tenant_id TEXT NOT NULL,
             plan_version_id TEXT NOT NULL,
             billing_interval TEXT NOT NULL,
+            pricing_audience TEXT NOT NULL DEFAULT 'public',
             stripe_price_id TEXT NOT NULL,
             pricing_type TEXT NOT NULL DEFAULT 'stripe',
             active INTEGER NOT NULL DEFAULT 1,
@@ -164,10 +165,10 @@ function setupBillingSchema(db) {
             currency TEXT,
             created_at TEXT NOT NULL,
             updated_at TEXT NOT NULL,
-            PRIMARY KEY (tenant_id, plan_version_id, billing_interval, stripe_price_id)
+            PRIMARY KEY (tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id)
         );
         CREATE UNIQUE INDEX idx_billing_price_mappings_active_interval
-        ON billing_price_mappings (tenant_id, plan_version_id, billing_interval)
+        ON billing_price_mappings (tenant_id, plan_version_id, billing_interval, pricing_audience)
         WHERE active = 1;
         CREATE TABLE plan_versions (
             plan_version_id TEXT PRIMARY KEY,
@@ -257,6 +258,7 @@ function readMockPlanVersionFeatures(db, tenantId, planVersionId) {
 function buildBillingRouteHandlers(db, opts) {
     const routes = new Map();
     const tenantId = 'default';
+    const siteSettings = opts?.siteSettings || {};
     const resolvePlanIdForVersion = (planVersionIdRaw) => {
         const planVersionId = String(planVersionIdRaw || '').trim();
         if (!planVersionId)
@@ -431,6 +433,9 @@ function buildBillingRouteHandlers(db, opts) {
             planId: planVersionId.startsWith('pro') ? 'pro' : 'starter',
             entitlementState: 'active'
         }),
+        getGlobalSettings: () => ({
+            site: siteSettings
+        }),
         resolveUserIdentity: () => opts?.userIdentity === undefined
             ? {
                 userId: 'u1',
@@ -1001,6 +1006,39 @@ describe('Billing Webhook Routes', () => {
         expect(args.customer).toBeUndefined();
         expect(args.customer_email).toBe('owner@example.com');
     });
+    it('creates checkout with the campaign price mapping when requested', async () => {
+        const now = new Date().toISOString();
+        db.prepare(`
+            INSERT INTO plan_versions (plan_version_id, tenant_id, plan_id, version_number, is_default, metadata_json, created_at, updated_at)
+            VALUES ('collab-v1', 'default', 'collab', 1, 1, '{}', ?, ?)
+        `).run(now, now);
+        db.prepare(`
+            INSERT INTO billing_price_mappings (tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id, active, created_at, updated_at)
+            VALUES ('default', 'collab-v1', 'month', 'public', 'price_collab_month', 1, ?, ?)
+        `).run(now, now);
+        db.prepare(`
+            INSERT INTO billing_price_mappings (tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id, active, created_at, updated_at)
+            VALUES ('default', 'collab-v1', 'month', 'campaign', 'price_collab_campaign_month', 1, ?, ?)
+        `).run(now, now);
+        const checkoutHandler = routeHandlers.get('POST /api/taskforce/billing/checkout-session');
+        const req = createMockReq(JSON.stringify({
+            planVersionId: 'collab-v1',
+            interval: 'month',
+            pricingAudience: 'campaign'
+        }), {
+            'x-taskforce-runtime-mode': 'cloud',
+            host: 'app.taskforcehq.ai'
+        });
+        const res = createMockRes();
+        await checkoutHandler?.(req, res, {});
+        expect(res.statusCode).toBe(200);
+        const args = mockCheckoutCreate.mock.calls.at(-1)?.[0];
+        expect(args.line_items?.[0]?.price).toBe('price_collab_campaign_month');
+        expect(String(args.success_url || '')).toContain('pricingAudience=campaign');
+        expect(String(args.cancel_url || '')).toContain('pricingAudience=campaign');
+        expect(args.metadata?.pricingAudience).toBe('campaign');
+        expect(args.subscription_data?.metadata?.pricingAudience).toBe('campaign');
+    });
     it('uses per-version trial days when creating checkout', async () => {
         const now = new Date().toISOString();
         db.prepare(`
@@ -2546,6 +2584,55 @@ describe('Billing Webhook Routes', () => {
             { stripe_price_id: 'price_old', active: 0, unit_amount: 1500 }
         ]);
     });
+    it('keeps campaign price mappings separate from public mappings in admin routes', async () => {
+        const now = new Date().toISOString();
+        db.prepare(`
+            INSERT INTO plan_versions (plan_version_id, tenant_id, plan_id, version_number, is_default, metadata_json, created_at, updated_at)
+            VALUES ('collab-v1', 'default', 'collab', 1, 1, '{}', ?, ?)
+        `).run(now, now);
+        db.prepare(`
+            INSERT INTO billing_price_mappings (tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at)
+            VALUES ('default', 'collab-v1', 'month', 'public', 'price_public', 'stripe', 1, 1500, 'usd', ?, ?)
+        `).run(now, now);
+        mockPriceRetrieve.mockResolvedValueOnce({
+            id: 'price_campaign',
+            active: true,
+            currency: 'usd',
+            unit_amount: 900,
+            recurring: { interval: 'month' }
+        });
+        const upsertRoute = routeHandlers.get('PUT /api/taskforce/admin/billing/price-mappings');
+        const upsertReq = createMockReq(JSON.stringify({
+            planVersionId: 'collab-v1',
+            interval: 'month',
+            pricingAudience: 'campaign',
+            stripePriceId: 'price_campaign',
+            active: true
+        }), { 'x-taskforce-runtime-mode': 'cloud' });
+        const upsertRes = createMockRes();
+        await upsertRoute(upsertReq, upsertRes, {});
+        expect(upsertRes.statusCode).toBe(200);
+        expect(JSON.parse(upsertRes.body)).toEqual(expect.objectContaining({
+            mapping: expect.objectContaining({
+                plan_version_id: 'collab-v1',
+                billing_interval: 'month',
+                pricing_audience: 'campaign',
+                stripe_price_id: 'price_campaign',
+                active: 1,
+                unit_amount: 900
+            })
+        }));
+        const rows = db.prepare(`
+            SELECT pricing_audience, stripe_price_id, active
+            FROM billing_price_mappings
+            WHERE tenant_id = 'default' AND plan_version_id = 'collab-v1' AND billing_interval = 'month'
+            ORDER BY pricing_audience ASC
+        `).all();
+        expect(rows).toEqual([
+            { pricing_audience: 'campaign', stripe_price_id: 'price_campaign', active: 1 },
+            { pricing_audience: 'public', stripe_price_id: 'price_public', active: 1 }
+        ]);
+    });
     it('rejects manual reuse of a Stripe price id across multiple plan versions', async () => {
         const now = new Date().toISOString();
         db.prepare(`
@@ -2723,6 +2810,10 @@ describe('Billing Webhook Routes', () => {
             INSERT INTO billing_price_mappings (tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at)
             VALUES ('default', 'pro-v1', 'month', 'price_pro_month', 'stripe', 1, 1500, 'usd', ?, ?)
         `).run(now, now);
+        db.prepare(`
+            INSERT INTO billing_price_mappings (tenant_id, plan_version_id, billing_interval, pricing_audience, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at)
+            VALUES ('default', 'pro-v1', 'month', 'campaign', 'price_pro_campaign_month', 'stripe', 1, 900, 'usd', ?, ?)
+        `).run(now, now);
         db.prepare(`
             INSERT INTO billing_price_mappings (tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at)
             VALUES ('default', 'starter-v1', 'month', 'free:starter-v1:month', 'free', 1, 0, NULL, ?, ?)
@@ -2733,6 +2824,8 @@ describe('Billing Webhook Routes', () => {
         expect(res.statusCode).toBe(200);
         const body = JSON.parse(res.body);
         expect(body.plans).toBeInstanceOf(Array);
+        expect(body.pageTitle).toBe('Subscription Plans');
+        expect(body.pageDescription).toBe('Manage your subscription and explore available features. Your current plan is highlighted below.');
         expect(body.pricingSource).toEqual({
             environment: 'production',
             runtimeMode: 'cloud'
@@ -2751,6 +2844,14 @@ describe('Billing Webhook Routes', () => {
         expect(monthPricing.currency).toBe('usd');
         expect(monthPricing.stripePriceId).toBe('price_pro_month');
         expect(proPlan.pricing.year).toBeNull();
+        expect(proPlan.campaignPricing.month).toEqual(expect.objectContaining({
+            pricingType: 'stripe',
+            unitAmount: 900,
+            currency: 'usd',
+            stripePriceId: 'price_pro_campaign_month',
+            interval: 'month'
+        }));
+        expect(proPlan.campaignPricing.year).toBeNull();
         // Free plan is explicitly free, not "missing"
         expect(freePlan.pricing.month.pricingType).toBe('free');
         expect(freePlan.pricing.month.unitAmount).toBe(0);
@@ -2791,6 +2892,40 @@ describe('Billing Webhook Routes', () => {
         const secondBody = JSON.parse(secondRes.body);
         expect(secondBody.plans.find((p) => p.planId === 'pro')?.pricing?.month?.unitAmount).toBe(2400);
     });
+    it('invalidates cached public pricing when pricing page header copy changes', async () => {
+        const now = new Date().toISOString();
+        const siteSettings = {};
+        routeHandlers = buildBillingRouteHandlers(db, { siteSettings });
+        const pricingRoute = routeHandlers.get('GET /api/taskforce/public/pricing');
+        expect(pricingRoute).toBeTypeOf('function');
+        db.prepare(`
+            INSERT INTO plan_versions (plan_version_id, tenant_id, plan_id, version_number, is_default, metadata_json, created_at, updated_at)
+            VALUES ('pro-v1', 'default', 'pro', 1, 1, '{}', ?, ?)
+        `).run(now, now);
+        db.prepare(`
+            INSERT INTO billing_price_mappings (
+                tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at
+            ) VALUES ('default', 'pro-v1', 'month', 'price_pro_month', 'stripe', 1, 1200, 'usd', ?, ?)
+        `).run(now, now);
+        const firstReq = createMockReq('', { 'x-taskforce-runtime-mode': 'cloud' });
+        const firstRes = createMockRes();
+        await pricingRoute(firstReq, firstRes, {});
+        expect(firstRes.statusCode).toBe(200);
+        expect(JSON.parse(firstRes.body)).toMatchObject({
+            pageTitle: 'Subscription Plans',
+            pageDescription: 'Manage your subscription and explore available features. Your current plan is highlighted below.'
+        });
+        siteSettings.pricingPageTitle = 'Choose Your Plan';
+        siteSettings.pricingPageDescription = 'Compare plans and pick the right fit for your team.';
+        const secondReq = createMockReq('', { 'x-taskforce-runtime-mode': 'cloud' });
+        const secondRes = createMockRes();
+        await pricingRoute(secondReq, secondRes, {});
+        expect(secondRes.statusCode).toBe(200);
+        expect(JSON.parse(secondRes.body)).toMatchObject({
+            pageTitle: 'Choose Your Plan',
+            pageDescription: 'Compare plans and pick the right fit for your team.'
+        });
+    });
     it('invalidates cached public pricing when plan features change', async () => {
         const now = new Date().toISOString();
         routeHandlers = buildBillingRouteHandlers(db);
@@ -2844,7 +2979,8 @@ describe('Billing Webhook Routes', () => {
     });
     it('includes public feature copy and invalidates cached public pricing when catalog overrides change', async () => {
         const now = new Date().toISOString();
-        routeHandlers = buildBillingRouteHandlers(db);
+        const siteSettings = {};
+        routeHandlers = buildBillingRouteHandlers(db, { siteSettings });
         const pricingRoute = routeHandlers.get('GET /api/taskforce/public/pricing');
         expect(pricingRoute).toBeTypeOf('function');
         db.prepare(`
@@ -2874,15 +3010,11 @@ describe('Billing Webhook Routes', () => {
                 featureKey: 'collaboration.ai_profiles',
                 label: 'AI Profiles',
                 publicLabel: 'AI teammates',
-                publicDescription: 'Add reusable AI teammates to your workspace.'
+                publicDescription: 'Add reusable AI teammates to your workspace.',
+                publicDescriptionVisible: false
             })
         ]);
-        const updatedAt = new Date(Date.now() + 1000).toISOString();
-        db.prepare(`
-            UPDATE plan_feature_catalog_overrides
-            SET public_label = 'AI copilots', updated_at = ?
-            WHERE tenant_id = 'default' AND feature_key = 'collaboration.ai_profiles'
-        `).run(updatedAt);
+        siteSettings.pricingPageShowPublicDescriptions = true;
         const secondReq = createMockReq('', { 'x-taskforce-runtime-mode': 'cloud' });
         const secondRes = createMockRes();
         await pricingRoute(secondReq, secondRes, {});
@@ -2891,7 +3023,25 @@ describe('Billing Webhook Routes', () => {
         expect(secondBody.plans.find((p) => p.planId === 'pro')?.features).toEqual([
             expect.objectContaining({
                 featureKey: 'collaboration.ai_profiles',
-                publicLabel: 'AI copilots'
+                publicDescriptionVisible: true
+            })
+        ]);
+        const updatedAt = new Date(Date.now() + 1000).toISOString();
+        db.prepare(`
+            UPDATE plan_feature_catalog_overrides
+            SET public_label = 'AI copilots', updated_at = ?
+            WHERE tenant_id = 'default' AND feature_key = 'collaboration.ai_profiles'
+        `).run(updatedAt);
+        const thirdReq = createMockReq('', { 'x-taskforce-runtime-mode': 'cloud' });
+        const thirdRes = createMockRes();
+        await pricingRoute(thirdReq, thirdRes, {});
+        expect(thirdRes.statusCode).toBe(200);
+        const thirdBody = JSON.parse(thirdRes.body);
+        expect(thirdBody.plans.find((p) => p.planId === 'pro')?.features).toEqual([
+            expect.objectContaining({
+                featureKey: 'collaboration.ai_profiles',
+                publicLabel: 'AI copilots',
+                publicDescriptionVisible: true
             })
         ]);
     });
@@ -2949,6 +3099,7 @@ describe('Billing Webhook Routes', () => {
         await pricingRoute(req, res, {});
         expect(res.statusCode).toBe(200);
         const body = JSON.parse(res.body);
+        expect(body.pageTitle).toBe('Subscription Plans');
         expect(body.pricingSource).toEqual({
             environment: 'performance',
             runtimeMode: 'cloud'

package/dist/server/routes/documents.js

@@ -474,6 +474,14 @@ export function registerDocumentRoutes(deps) {
                     if (shouldProxyInlineUserAvatar && await proxyCloudUserProfileAvatar(req, res, normalizedRelative, contentTypeForExt)) {
                         return;
                     }
+                    if (shouldProxyInlineAiAvatar && filePath && fs.existsSync(filePath)) {
+                        res.writeHead(200, {
+                            'Content-Type': contentTypeForExt(ext),
+                            'Content-Disposition': contentDisposition
+                        });
+                        res.end(fs.readFileSync(filePath));
+                        return;
+                    }
                     res.writeHead(404, { 'Content-Type': 'text/plain' });
                     res.end('Context file not found');
                     return;
@@ -873,6 +881,7 @@ export function registerDocumentRoutes(deps) {
             }));
             return;
         }
+        const attachedAt = new Date().toISOString();
         const payload = buildTaskAttachmentPayload(asset.storageKey, {
             caption: getCanonicalDocumentName({
                 assetId: asset.assetId,
@@ -883,6 +892,7 @@ export function registerDocumentRoutes(deps) {
             }),
             assetId: asset.assetId,
             taskId: targetId,
+            timestamp: attachedAt,
         });
         if (!payload) {
             res.writeHead(500, { 'Content-Type': 'application/json' });

package/dist/server/routes/shared.js

@@ -216,16 +216,6 @@ export function makeResolveAuthenticatedMutationUserId(core, context, requestWor
         const explicitUserId = String(requestUserId(req) || '').trim();
         if (explicitUserId && explicitUserId !== 'anonymous')
             return explicitUserId;
-        if (requestRuntimeMode(req) === 'local') {
-            const workspaceId = String(requestWorkspaceId(req) || '').trim() || 'default';
-            const fallbackUser = core.listWorkspaceUsers(workspaceId).find((user) => {
-                const status = String(user.status || '').trim().toLowerCase();
-                return status === 'active' && user.disabled !== true;
-            });
-            const fallbackUserId = String(fallbackUser?.userId || '').trim();
-            if (fallbackUserId)
-                return fallbackUserId;
-        }
         throw new TaskforceRuleError('Authenticated user required for mutation attribution.', 401, 'MUTATION_AUTH_REQUIRED');
     };
 }

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

@@ -1676,6 +1676,227 @@ describe('Server Routes Workspace Sync Integration', () => {
             })
         ]);
     });
+    it('round-trips planning attachment links through pull and apply-local routes', async () => {
+        const cloudProjectRoot = createIsolatedProjectRoot('taskforce-sync-planning-link-cloud-');
+        const localProjectRoot = createIsolatedProjectRoot('taskforce-sync-planning-link-local-');
+        const cloudCore = new TaskforceCore({ projectRoot: cloudProjectRoot, storagePath: '.taskforce' });
+        seedAuthenticatedWorkspace(cloudCore);
+        cloudCore.createInitiative({
+            id: 'initiative-cloud-link-roundtrip-1',
+            title: 'Cloud initiative attachment target',
+            createdAt: '2026-03-18T09:00:00.000Z',
+            updatedAt: '2026-03-18T09:00:00.000Z'
+        }, workspaceId);
+        cloudCore.createWorkstream({
+            id: 'workstream-cloud-link-roundtrip-1',
+            initiativeId: 'initiative-cloud-link-roundtrip-1',
+            title: 'Cloud workstream attachment target',
+            createdAt: '2026-03-18T09:00:00.000Z',
+            updatedAt: '2026-03-18T09:00:00.000Z'
+        }, workspaceId);
+        const cloudBasePath = cloudCore.getPaths().basePath;
+        const cloudStore = new WorkspaceAssetStore(cloudCore.getDatabaseAdapter(), cloudCore.getTenantId());
+        const markdownPath = `workspaces/${workspaceId}/assets/documents/asset-cloud-planning-link-plan.md`;
+        const filePath = `workspaces/${workspaceId}/assets/files/asset-cloud-planning-link-notes.txt`;
+        fs.mkdirSync(path.dirname(path.join(cloudBasePath, markdownPath)), { recursive: true });
+        fs.mkdirSync(path.dirname(path.join(cloudBasePath, filePath)), { recursive: true });
+        fs.writeFileSync(path.join(cloudBasePath, markdownPath), '# planning sync\n', 'utf8');
+        fs.writeFileSync(path.join(cloudBasePath, filePath), 'planning attachment', 'utf8');
+        cloudStore.upsertAsset({
+            assetId: 'asset-cloud-planning-link-doc-1',
+            workspaceId,
+            kind: 'document',
+            originalFilename: 'plan.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: markdownPath,
+            contentSha256: 'planning-doc-roundtrip-hash',
+            sizeBytes: '# planning sync\n'.length,
+            documentId: 'doc-cloud-planning-link-1',
+            version: 1,
+            isLatest: true,
+            createdAt: '2026-03-18T09:00:00.000Z',
+            updatedAt: '2026-03-18T09:00:00.000Z'
+        });
+        cloudStore.upsertLink({
+            workspaceId,
+            assetId: 'asset-cloud-planning-link-doc-1',
+            targetType: 'initiative',
+            targetId: 'initiative-cloud-link-roundtrip-1',
+            role: 'attachment',
+            updatedAt: '2026-03-18T10:00:00.000Z'
+        });
+        cloudStore.upsertAsset({
+            assetId: 'asset-cloud-planning-link-file-1',
+            workspaceId,
+            kind: 'file',
+            originalFilename: 'notes.txt',
+            mimeType: 'text/plain',
+            storageProvider: 'local',
+            storageKey: filePath,
+            contentSha256: 'planning-file-roundtrip-hash',
+            sizeBytes: 'planning attachment'.length,
+            isLatest: true,
+            createdAt: '2026-03-18T09:00:00.000Z',
+            updatedAt: '2026-03-18T09:00:00.000Z'
+        });
+        cloudStore.upsertLink({
+            workspaceId,
+            assetId: 'asset-cloud-planning-link-file-1',
+            targetType: 'workstream',
+            targetId: 'workstream-cloud-link-roundtrip-1',
+            role: 'attachment',
+            updatedAt: '2026-03-18T10:00:01.000Z'
+        });
+        const cloudRoutes = createRoutes(cloudCore, { authConfig });
+        const pullMatch = matchRoute('GET', '/api/taskforce/sync/workspace/pull', cloudRoutes);
+        expect(pullMatch).toBeTruthy();
+        const cookie = createAuthCookie(workspaceId);
+        const pullReq = createMockReq('GET', '/api/taskforce/sync/workspace/pull?workspaceId=workspace-local-active&limit=50&cursor=eyJ1IjoiMjAyNi0wMy0xOFQwOTozMDowMC4wMDBaIiwiaWQiOiJzZWVkIn0', undefined, { cookie });
+        const pullRes = createMockRes();
+        await pullMatch?.handler(pullReq, pullRes, {});
+        expect(pullRes.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const pullBody = readJsonBody(pullRes);
+        const pulledChanges = Array.isArray(pullBody?.changes) ? pullBody.changes : [];
+        expect(pulledChanges).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                op: 'document-upsert',
+                path: markdownPath,
+                assetId: 'asset-cloud-planning-link-doc-1',
+                linkTargetType: 'initiative',
+                linkTargetId: 'initiative-cloud-link-roundtrip-1',
+                originalFilename: 'plan.md',
+                linkRole: 'attachment'
+            }),
+            expect.objectContaining({
+                op: 'asset-upsert',
+                path: filePath,
+                assetId: 'asset-cloud-planning-link-file-1',
+                linkTargetType: 'workstream',
+                linkTargetId: 'workstream-cloud-link-roundtrip-1',
+                originalFilename: 'notes.txt',
+                linkRole: 'attachment'
+            })
+        ]));
+        const localCore = new TaskforceCore({ projectRoot: localProjectRoot, storagePath: '.taskforce' });
+        localCore.createWorkspace({ workspaceId, name: 'Local Active Workspace' });
+        localCore.createInitiative({
+            id: 'initiative-cloud-link-roundtrip-1',
+            title: 'Local initiative attachment target',
+            createdAt: '2026-03-18T09:00:00.000Z',
+            updatedAt: '2026-03-18T09:00:00.000Z'
+        }, workspaceId);
+        localCore.createWorkstream({
+            id: 'workstream-cloud-link-roundtrip-1',
+            initiativeId: 'initiative-cloud-link-roundtrip-1',
+            title: 'Local workstream attachment target',
+            createdAt: '2026-03-18T09:00:00.000Z',
+            updatedAt: '2026-03-18T09:00:00.000Z'
+        }, workspaceId);
+        const localRoutes = createRoutes(localCore, { authConfig: { runtimeMode: 'local', enabled: false } });
+        const applyMatch = matchRoute('POST', '/api/taskforce/sync/workspace/apply-local', localRoutes);
+        expect(applyMatch).toBeTruthy();
+        const applyReq = createMockReq('POST', '/api/taskforce/sync/workspace/apply-local', { changes: pulledChanges }, { 'x-taskforce-workspace-id': workspaceId });
+        const applyRes = createMockRes();
+        await applyMatch?.handler(applyReq, applyRes, {});
+        expect(applyRes.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const reloadedLocalCore = new TaskforceCore({ projectRoot: localProjectRoot, storagePath: '.taskforce' });
+        const reloadedStore = new WorkspaceAssetStore(reloadedLocalCore.getDatabaseAdapter(), reloadedLocalCore.getTenantId());
+        expect(fs.readFileSync(path.join(reloadedLocalCore.getPaths().basePath, markdownPath), 'utf8')).toBe('# planning sync\n');
+        expect(fs.readFileSync(path.join(reloadedLocalCore.getPaths().basePath, filePath), 'utf8')).toBe('planning attachment');
+        expect(reloadedStore.listLinksForAsset('asset-cloud-planning-link-doc-1', workspaceId)).toEqual([
+            expect.objectContaining({
+                targetType: 'initiative',
+                targetId: 'initiative-cloud-link-roundtrip-1',
+                taskId: null,
+                role: 'attachment',
+                deletedAt: null
+            })
+        ]);
+        expect(reloadedStore.listLinksForAsset('asset-cloud-planning-link-file-1', workspaceId)).toEqual([
+            expect.objectContaining({
+                targetType: 'workstream',
+                targetId: 'workstream-cloud-link-roundtrip-1',
+                taskId: null,
+                role: 'attachment',
+                deletedAt: null
+            })
+        ]);
+    });
+    it('pushes document attachment links when only the link metadata changed locally', async () => {
+        const projectRoot = createIsolatedProjectRoot('taskforce-sync-doc-link-only-push-');
+        const seedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        seedAuthenticatedWorkspace(seedCore);
+        seedCore.createTask({
+            id: 'task-doc-link-only-push-1',
+            title: 'Document link target',
+            status: 'task'
+        }, {
+            workspaceId,
+            allowClientProvidedId: true
+        });
+        const seedBasePath = seedCore.getPaths().basePath;
+        const relativeDocPath = `workspaces/${workspaceId}/assets/documents/asset-doc-link-only-push-plan.md`;
+        const absoluteDocPath = path.join(seedBasePath, relativeDocPath);
+        const content = '# already synced\n';
+        fs.mkdirSync(path.dirname(absoluteDocPath), { recursive: true });
+        fs.writeFileSync(absoluteDocPath, content, 'utf8');
+        const contentHash = createHash('sha256').update(content).digest('hex');
+        seedCore.upsertDocumentWatermark(workspaceId, relativeDocPath, contentHash, '2026-03-18T13:30:00.000Z');
+        const seedStore = new WorkspaceAssetStore(seedCore.getDatabaseAdapter(), seedCore.getTenantId());
+        seedStore.upsertAsset({
+            assetId: 'asset-doc-link-only-push-1',
+            workspaceId,
+            kind: 'document',
+            originalFilename: 'plan.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: relativeDocPath,
+            contentSha256: contentHash,
+            sizeBytes: Buffer.byteLength(content, 'utf8'),
+            documentId: 'doc-link-only-push-1',
+            version: 1,
+            isLatest: true,
+            createdAt: '2026-03-18T13:30:00.000Z',
+            updatedAt: '2026-03-18T13:30:00.000Z'
+        });
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const routes = createRoutes(core, { authConfig });
+        const pushMatch = matchRoute('POST', '/api/taskforce/sync/workspace/push', routes);
+        expect(pushMatch).toBeTruthy();
+        const req = createMockReq('POST', '/api/taskforce/sync/workspace/push', {
+            workspaceId,
+            idempotencyKey: 'doc-link-only-push-1',
+            changes: [
+                {
+                    op: 'document-upsert',
+                    path: relativeDocPath,
+                    updatedAt: '2026-03-18T14:45:00.000Z',
+                    content,
+                    assetId: 'asset-doc-link-only-push-1',
+                    documentId: 'doc-link-only-push-1',
+                    referenceNumber: 12,
+                    version: 1,
+                    taskId: 'task-doc-link-only-push-1',
+                    originalFilename: 'plan.md',
+                    linkRole: 'attachment'
+                }
+            ]
+        }, { cookie: createAuthCookie(workspaceId) });
+        const res = createMockRes();
+        await pushMatch?.handler(req, res, {});
+        expect(res.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const reloadedStore = new WorkspaceAssetStore(reloadedCore.getDatabaseAdapter(), reloadedCore.getTenantId());
+        expect(reloadedStore.listLinksForAsset('asset-doc-link-only-push-1', workspaceId)).toEqual([
+            expect.objectContaining({
+                taskId: 'task-doc-link-only-push-1',
+                role: 'attachment',
+                updatedAt: '2026-03-18T14:45:00.000Z',
+                deletedAt: null
+            })
+        ]);
+    });
     it('propagates document-delete through authenticated push and omits deleted doc from pull payload', async () => {
         const projectRoot = createIsolatedProjectRoot('taskforce-sync-push-pull-doc-delete-');
         const seedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });

package/dist/server/routes/sync.js

@@ -3,7 +3,7 @@ import { parseJsonBody } from './primitives.js';
 import { normalizeTaskDataRelativePath, ObjectStorageClient } from '../../storage/objectStorageClient.js';
 import { WorkspaceAssetStore, } from '../../storage/workspaceAssetStore.js';
 import { resolveSessionCookieAttributesForRequest } from '../auth.js';
-import { isAiProfileSurfaceType } from '../../shared/aiProfileSurfaceType.js';
+import { isAiProfileSurfaceType, parseAiProfileSurfaceType } from '../../shared/aiProfileSurfaceType.js';
 import { isAiProfileSeatScope } from '../../shared/aiProfileSeatScope.js';
 import { serializeBinaryAssetSyncPayload, serializeDocumentSyncPayload, } from '../../sync/contentSyncPayload.js';
 import { createContentSyncState } from '../../sync/contentSyncState.js';
@@ -52,6 +52,8 @@ function normalizeIncomingAiProfileSurfaceType(value, context) {
     const normalized = String(value || '').trim();
     if (!normalized)
         return null;
+    if (normalized === 'other')
+        return parseAiProfileSurfaceType(normalized);
     if (!isAiProfileSurfaceType(normalized)) {
         throw createSyncRouteError(`Invalid ai profile surfaceType "${normalized}"`, {
             ...context,
@@ -79,11 +81,17 @@ function normalizeTaskEventSyncPayload(raw, workspaceId, sourceWatermark) {
         return null;
     const source = raw;
     const id = String(source.id || '').trim();
+    const entityType = source.entityType === 'initiative' || source.entityType === 'workstream'
+        ? source.entityType
+        : source.entity_type === 'initiative' || source.entity_type === 'workstream'
+            ? source.entity_type
+            : 'task';
     const taskId = String(source.taskId || source.task_id || '').trim();
+    const entityId = String(source.entityId || source.entity_id || taskId).trim();
     const action = String(source.action || '').trim();
     const actor = String(source.actor || 'system').trim() || 'system';
     const createdAt = String(source.createdAt || source.created_at || sourceWatermark || '').trim();
-    if (!id || !taskId || !action || !Number.isFinite(Date.parse(createdAt)))
+    if (!id || !entityId || !action || !Number.isFinite(Date.parse(createdAt)))
         return null;
     const actorType = source.actorType === 'ai' || source.actorType === 'human' || source.actorType === 'system'
         ? source.actorType
@@ -99,8 +107,10 @@ function normalizeTaskEventSyncPayload(raw, workspaceId, sourceWatermark) {
         : {};
     return {
         id,
-        taskId,
         workspaceId,
+        entityType,
+        entityId,
+        taskId: entityType === 'task' ? (taskId || entityId) : undefined,
         action,
         actor,
         actorType,

package/dist/server/routes/syncSnapshotRoutes.js

@@ -59,6 +59,8 @@ export function registerWorkspaceSnapshotSyncRoutes({ addRoute, core, context, r
             profile.profileToken,
             profile.avatarUrl ?? '',
             profile.avatarSourceUrl ?? '',
+            profile.avatarRevision ?? 0,
+            profile.avatarUpdatedAt ?? '',
             profile.surfaceType ?? '',
             profile.seatScope ?? '',
             profile.archivedAt ?? '',