@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/storage/workspaceAssetStore.js

@@ -47,11 +47,15 @@ function mapAssetRow(row) {
     };
 }
 function mapLinkRow(row) {
+    const targetType = String(row.target_type || 'task').trim();
+    const targetId = String(row.task_id || '').trim();
     return {
         tenantId: String(row.tenant_id || 'default'),
         workspaceId: String(row.workspace_id || 'default'),
         assetId: String(row.asset_id || ''),
-        taskId: String(row.task_id || ''),
+        targetType,
+        targetId,
+        taskId: targetType === 'task' ? targetId : null,
         role: String(row.role || 'attachment'),
         displayName: row.display_name == null ? null : String(row.display_name),
         sortOrder: row.sort_order == null ? null : Number(row.sort_order),
@@ -73,10 +77,36 @@ function usesReadableAssetReference(kind) {
 export class WorkspaceAssetStore {
     db;
     tenantId;
+    supportsTargetTypeCache = null;
     constructor(db, tenantId) {
         this.db = db;
         this.tenantId = tenantId;
     }
+    supportsTargetType() {
+        if (this.supportsTargetTypeCache !== null)
+            return this.supportsTargetTypeCache;
+        try {
+            if (this.db.provider === 'postgres') {
+                const row = this.db.prepare(`
+                    SELECT 1
+                    FROM information_schema.columns
+                    WHERE table_schema = current_schema()
+                      AND table_name = 'workspace_asset_links'
+                      AND column_name = 'target_type'
+                    LIMIT 1
+                `).get();
+                this.supportsTargetTypeCache = Boolean(row);
+                return this.supportsTargetTypeCache;
+            }
+            const columns = this.db.prepare(`PRAGMA table_info(workspace_asset_links)`).all();
+            this.supportsTargetTypeCache = columns.some((column) => String(column.name || '').trim() === 'target_type');
+            return this.supportsTargetTypeCache;
+        }
+        catch {
+            this.supportsTargetTypeCache = false;
+            return false;
+        }
+    }
     normalizePersistedAsset(entry) {
         const normalizedKind = normalizeCanonicalAssetKind({
             kind: entry.kind,
@@ -411,47 +441,93 @@ export class WorkspaceAssetStore {
     upsertLink(input) {
         const workspaceId = normalizeWorkspaceId(input.workspaceId);
         const assetId = normalizeId(input.assetId);
-        const taskId = normalizeId(input.taskId);
+        const targetType = normalizeId(input.targetType, input.taskId ? 'task' : 'task');
+        const targetId = normalizeId(input.targetId, input.taskId || '');
         const role = normalizeId(input.role, 'attachment');
         const createdAt = normalizeId(input.createdAt, new Date().toISOString());
         const updatedAt = normalizeId(input.updatedAt, createdAt);
-        this.db.prepare(`
-            INSERT INTO workspace_asset_links (
-                tenant_id,
-                workspace_id,
-                asset_id,
-                task_id,
-                role,
-                display_name,
-                sort_order,
-                created_at,
-                updated_at,
-                deleted_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(tenant_id, workspace_id, asset_id, task_id, role) DO UPDATE SET
-                display_name = excluded.display_name,
-                sort_order = excluded.sort_order,
-                updated_at = excluded.updated_at,
-                deleted_at = excluded.deleted_at
-        `).run(this.tenantId, workspaceId, assetId, taskId, role, normalizeNullable(input.displayName), input.sortOrder == null ? null : Math.floor(Number(input.sortOrder)), createdAt, updatedAt, normalizeNullable(input.deletedAt));
+        if (!targetId) {
+            throw new Error('Workspace asset links require a targetId.');
+        }
+        if (this.supportsTargetType()) {
+            this.db.prepare(`
+                INSERT INTO workspace_asset_links (
+                    tenant_id,
+                    workspace_id,
+                    asset_id,
+                    target_type,
+                    task_id,
+                    role,
+                    display_name,
+                    sort_order,
+                    created_at,
+                    updated_at,
+                    deleted_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(tenant_id, workspace_id, asset_id, task_id, role) DO UPDATE SET
+                    target_type = excluded.target_type,
+                    display_name = excluded.display_name,
+                    sort_order = excluded.sort_order,
+                    updated_at = excluded.updated_at,
+                    deleted_at = excluded.deleted_at
+            `).run(this.tenantId, workspaceId, assetId, targetType, targetId, role, normalizeNullable(input.displayName), input.sortOrder == null ? null : Math.floor(Number(input.sortOrder)), createdAt, updatedAt, normalizeNullable(input.deletedAt));
+        }
+        else {
+            this.db.prepare(`
+                INSERT INTO workspace_asset_links (
+                    tenant_id,
+                    workspace_id,
+                    asset_id,
+                    task_id,
+                    role,
+                    display_name,
+                    sort_order,
+                    created_at,
+                    updated_at,
+                    deleted_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(tenant_id, workspace_id, asset_id, task_id, role) DO UPDATE SET
+                    display_name = excluded.display_name,
+                    sort_order = excluded.sort_order,
+                    updated_at = excluded.updated_at,
+                    deleted_at = excluded.deleted_at
+            `).run(this.tenantId, workspaceId, assetId, targetId, role, normalizeNullable(input.displayName), input.sortOrder == null ? null : Math.floor(Number(input.sortOrder)), createdAt, updatedAt, normalizeNullable(input.deletedAt));
+        }
         return this.listLinksForAsset(assetId, workspaceId, { includeDeleted: true })
-            .find((entry) => entry.taskId === taskId && entry.role === role);
+            .find((entry) => entry.targetType === targetType && entry.targetId === targetId && entry.role === role);
     }
     listLinksForTask(taskIdRaw, workspaceIdRaw, options) {
+        return this.listLinksForTarget('task', taskIdRaw, workspaceIdRaw, options);
+    }
+    listLinksForTarget(targetTypeRaw, targetIdRaw, workspaceIdRaw, options) {
         const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
-        const taskId = normalizeId(taskIdRaw);
-        if (!taskId)
+        const targetType = normalizeId(targetTypeRaw, 'task');
+        const targetId = normalizeId(targetIdRaw);
+        if (!targetId)
             return [];
         const includeDeleted = options?.includeDeleted === true;
-        const rows = this.db.prepare(`
-            SELECT *
-            FROM workspace_asset_links
-            WHERE tenant_id = ?
-              AND workspace_id = ?
-              AND task_id = ?
-              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
-            ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, asset_id ASC
-        `).all(this.tenantId, workspaceId, taskId);
+        const rows = this.supportsTargetType()
+            ? this.db.prepare(`
+                SELECT *
+                FROM workspace_asset_links
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                  AND target_type = ?
+                  AND task_id = ?
+                  ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+                ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, asset_id ASC
+            `).all(this.tenantId, workspaceId, targetType, targetId)
+            : (targetType === 'task'
+                ? this.db.prepare(`
+                        SELECT *
+                        FROM workspace_asset_links
+                        WHERE tenant_id = ?
+                          AND workspace_id = ?
+                          AND task_id = ?
+                          ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+                        ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, asset_id ASC
+                    `).all(this.tenantId, workspaceId, targetId)
+                : []);
         return rows.map(mapLinkRow);
     }
     listLinksForAsset(assetIdRaw, workspaceIdRaw, options) {
@@ -474,23 +550,35 @@ export class WorkspaceAssetStore {
     deleteLink(input) {
         const workspaceId = normalizeWorkspaceId(input.workspaceId);
         const assetId = normalizeId(input.assetId);
-        const taskId = normalizeId(input.taskId);
+        const targetType = normalizeId(input.targetType, input.taskId ? 'task' : 'task');
+        const targetId = normalizeId(input.targetId, input.taskId || '');
         const role = normalizeId(input.role);
-        if (!assetId || !taskId || !role)
+        if (!assetId || !targetId || !role)
             return false;
         if (input.hardDelete) {
-            const result = this.db.prepare(`
-                DELETE FROM workspace_asset_links
-                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
-            `).run(this.tenantId, workspaceId, assetId, taskId, role);
+            const result = this.supportsTargetType()
+                ? this.db.prepare(`
+                    DELETE FROM workspace_asset_links
+                    WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND target_type = ? AND task_id = ? AND role = ?
+                `).run(this.tenantId, workspaceId, assetId, targetType, targetId, role)
+                : this.db.prepare(`
+                    DELETE FROM workspace_asset_links
+                    WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
+                `).run(this.tenantId, workspaceId, assetId, targetId, role);
             return Number(result?.changes || 0) > 0;
         }
         const nowIso = new Date().toISOString();
-        const result = this.db.prepare(`
-            UPDATE workspace_asset_links
-            SET deleted_at = ?, updated_at = ?
-            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
-        `).run(nowIso, nowIso, this.tenantId, workspaceId, assetId, taskId, role);
+        const result = this.supportsTargetType()
+            ? this.db.prepare(`
+                UPDATE workspace_asset_links
+                SET deleted_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND target_type = ? AND task_id = ? AND role = ?
+            `).run(nowIso, nowIso, this.tenantId, workspaceId, assetId, targetType, targetId, role)
+            : this.db.prepare(`
+                UPDATE workspace_asset_links
+                SET deleted_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
+            `).run(nowIso, nowIso, this.tenantId, workspaceId, assetId, targetId, role);
         return Number(result?.changes || 0) > 0;
     }
 }

package/dist/storage/workspaceAssetStore.test.js

@@ -23,6 +23,40 @@ function makeStore() {
         }
     };
 }
+function makeLegacyLinkStore() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-workspace-assets-legacy-'));
+    const dbPath = path.join(root, 'taskforce.db');
+    const db = createDatabaseAdapter({ sqliteDbPath: dbPath });
+    ensureTaskAssetsSchema(db);
+    ensureWorkspaceAssetsSchema(db);
+    ensureDocumentReferenceSchema(db);
+    db.exec(`DROP TABLE IF EXISTS workspace_asset_links`);
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS workspace_asset_links (
+            tenant_id TEXT NOT NULL DEFAULT 'default',
+            workspace_id TEXT NOT NULL,
+            asset_id TEXT NOT NULL,
+            task_id TEXT NOT NULL,
+            role TEXT NOT NULL,
+            display_name TEXT,
+            sort_order INTEGER,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            deleted_at TEXT,
+            PRIMARY KEY (tenant_id, workspace_id, asset_id, task_id, role)
+        );
+    `);
+    const store = new WorkspaceAssetStore(db, 'default');
+    return {
+        root,
+        db,
+        store,
+        cleanup() {
+            db.close();
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    };
+}
 describe('WorkspaceAssetStore', () => {
     const cleanups = [];
     afterEach(() => {
@@ -64,6 +98,50 @@ describe('WorkspaceAssetStore', () => {
             referenceNumber: 1
         });
     });
+    it('supports legacy workspace asset links without target_type', () => {
+        const ctx = makeLegacyLinkStore();
+        cleanups.push(() => ctx.cleanup());
+        const now = new Date().toISOString();
+        ctx.store.upsertAsset({
+            assetId: 'asset-legacy-1',
+            workspaceId: 'workspace-1',
+            kind: 'file',
+            originalFilename: 'legacy.pdf',
+            mimeType: 'application/pdf',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/files/asset-legacy-1-legacy.pdf',
+            contentSha256: 'sha-legacy',
+            sizeBytes: 42,
+            createdAt: now,
+            updatedAt: now
+        });
+        const created = ctx.store.upsertLink({
+            workspaceId: 'workspace-1',
+            assetId: 'asset-legacy-1',
+            taskId: 'task-1',
+            role: 'attachment',
+            displayName: 'Legacy attachment',
+            createdAt: now,
+            updatedAt: now
+        });
+        expect(created.targetType).toBe('task');
+        expect(created.targetId).toBe('task-1');
+        expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-legacy-1',
+                targetType: 'task',
+                targetId: 'task-1',
+                role: 'attachment'
+            })
+        ]);
+        expect(ctx.store.deleteLink({
+            workspaceId: 'workspace-1',
+            assetId: 'asset-legacy-1',
+            taskId: 'task-1',
+            role: 'attachment'
+        })).toBe(true);
+        expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toEqual([]);
+    });
     it('assigns sequential document reference numbers per workspace', () => {
         const ctx = makeStore();
         cleanups.push(() => ctx.cleanup());
@@ -382,7 +460,7 @@ describe('WorkspaceAssetStore', () => {
         const all = ctx.store.listByWorkspace('workspace-1', { includeDeleted: true });
         expect(all.map((entry) => entry.assetId).sort()).toEqual(['asset-a', 'asset-b']);
     });
-    it('creates, lists, and soft-deletes task links separately from asset identity', () => {
+    it('creates, lists, and soft-deletes generic target links while preserving task compatibility helpers', () => {
         const ctx = makeStore();
         cleanups.push(() => ctx.cleanup());
         ctx.store.upsertAsset({
@@ -399,27 +477,36 @@ describe('WorkspaceAssetStore', () => {
         ctx.store.upsertLink({
             workspaceId: 'workspace-1',
             assetId: 'asset-link-1',
-            taskId: 'task-1',
+            targetType: 'task',
+            targetId: 'task-1',
             role: 'attachment',
             sortOrder: 2
         });
         ctx.store.upsertLink({
             workspaceId: 'workspace-1',
             assetId: 'asset-link-1',
-            taskId: 'task-2',
+            targetType: 'initiative',
+            targetId: 'initiative-2',
             role: 'reference',
             sortOrder: 1
         });
         const taskLinks = ctx.store.listLinksForTask('task-1', 'workspace-1');
         expect(taskLinks).toHaveLength(1);
-        expect(taskLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'attachment' });
+        expect(taskLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'attachment', targetType: 'task', targetId: 'task-1', taskId: 'task-1' });
+        const initiativeLinks = ctx.store.listLinksForTarget('initiative', 'initiative-2', 'workspace-1');
+        expect(initiativeLinks).toHaveLength(1);
+        expect(initiativeLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'reference', targetType: 'initiative', targetId: 'initiative-2', taskId: null });
         const assetLinks = ctx.store.listLinksForAsset('asset-link-1', 'workspace-1');
         expect(assetLinks).toHaveLength(2);
-        expect(assetLinks.map((entry) => entry.taskId)).toEqual(['task-2', 'task-1']);
+        expect(assetLinks.map((entry) => [entry.targetType, entry.targetId])).toEqual([
+            ['initiative', 'initiative-2'],
+            ['task', 'task-1'],
+        ]);
         expect(ctx.store.deleteLink({
             workspaceId: 'workspace-1',
             assetId: 'asset-link-1',
-            taskId: 'task-1',
+            targetType: 'task',
+            targetId: 'task-1',
             role: 'attachment'
         })).toBe(true);
         expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toHaveLength(0);

package/dist/styles/fonts.css

@@ -0,0 +1,70 @@
+@font-face {
+  font-family: "Russo One";
+  src: url("../assets/fonts/RussoOne-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Courier Prime";
+  src: url("../assets/fonts/CourierPrime-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Courier Prime";
+  src: url("../assets/fonts/CourierPrime-Italic.woff2") format("woff2");
+  font-weight: 400;
+  font-style: italic;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Courier Prime";
+  src: url("../assets/fonts/CourierPrime-Bold.woff2") format("woff2");
+  font-weight: 700;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Courier Prime";
+  src: url("../assets/fonts/CourierPrime-BoldItalic.woff2") format("woff2");
+  font-weight: 700;
+  font-style: italic;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Special Elite";
+  src: url("../assets/fonts/SpecialElite-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Noir";
+  src: url("../assets/fonts/Noir_regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "Noir";
+  src: url("../assets/fonts/Noir_medium.woff2") format("woff2");
+  font-weight: 500;
+  font-style: normal;
+  font-display: swap;
+}
+
+:root {
+  --font-brand: "Russo One", sans-serif;
+  --font-typewriter: "Courier Prime", "Courier New", Courier, monospace;
+  --font-stamped: "Special Elite", "Courier Prime", "Courier New", Courier, monospace;
+  --font-noir: "Noir", var(--font-sans, ui-sans-serif, system-ui, sans-serif);
+}

package/dist/sync/collaborationSyncPayload.d.ts

@@ -1,10 +1,15 @@
 import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot } from './workspaceSyncModel.js';
 import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import type { AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 export declare function normalizeAiProfileSyncPayload(raw: unknown, workspaceId: string, normalizeSurfaceType: (value: unknown, context: {
     source: string;
     profileId?: string;
     workspaceId?: string;
-}) => AiProfileSurfaceType | null, source: string): WorkspaceSyncAiProfileSnapshot | null;
+}) => AiProfileSurfaceType | null, normalizeSeatScope: (value: unknown, context: {
+    source: string;
+    profileId?: string;
+    workspaceId?: string;
+}) => AiProfileSeatScope | null, source: string): WorkspaceSyncAiProfileSnapshot | null;
 export declare function normalizeDocumentReviewSessionSyncPayload(raw: unknown, sourceWatermark?: string): WorkspaceSyncDocumentReviewSessionSnapshot | null;
 export declare function normalizeDocumentReviewCommentSyncPayload(raw: unknown, options?: {
     sessionId?: string;

package/dist/sync/collaborationSyncPayload.js

@@ -1,11 +1,9 @@
+import { hasOwnSyncField, normalizeSyncNullableString, normalizeSyncOptionalString, readSyncNullableIdField, readSyncNullableIsoStringField, readSyncNullableStringField, readSyncSameOriginAssetUrlField, } from './syncFieldSemantics.js';
 function toOptionalTrimmedString(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const normalized = value.trim();
-    return normalized.length > 0 ? normalized : undefined;
+    return normalizeSyncOptionalString(value);
 }
 function toNullableTrimmedString(value) {
-    return toOptionalTrimmedString(value) ?? null;
+    return normalizeSyncNullableString(value);
 }
 function toOptionalPositiveInteger(value) {
     if (value === undefined || value === null || value === '')
@@ -23,7 +21,7 @@ function toOptionalNonNegativeInteger(value) {
         return 0;
     return Math.max(0, Math.floor(normalized));
 }
-export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurfaceType, source) {
+export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurfaceType, normalizeSeatScope, source) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return null;
     const profile = raw;
@@ -39,17 +37,27 @@ export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurface
         username: String(profile.username || '').trim(),
         icon: String(profile.icon || 'Bot').trim() || 'Bot',
         color: String(profile.color || '#8b5cf6').trim() || '#8b5cf6',
-        description: toNullableTrimmedString(profile.description),
-        role: toNullableTrimmedString(profile.role),
-        provider: toNullableTrimmedString(profile.provider),
-        model: toNullableTrimmedString(profile.model),
+        ...(hasOwnSyncField(profile, 'avatarUrl') ? { avatarUrl: readSyncSameOriginAssetUrlField(profile, 'avatarUrl') ?? null } : {}),
+        ...(hasOwnSyncField(profile, 'avatarSourceUrl') ? { avatarSourceUrl: readSyncSameOriginAssetUrlField(profile, 'avatarSourceUrl') ?? null } : {}),
+        ...(hasOwnSyncField(profile, 'avatarRevision') ? { avatarRevision: toOptionalNonNegativeInteger(profile.avatarRevision) } : {}),
+        avatarUpdatedAt: readSyncNullableIsoStringField(profile, 'avatarUpdatedAt') ?? null,
+        description: readSyncNullableStringField(profile, 'description') ?? null,
+        role: readSyncNullableStringField(profile, 'role') ?? null,
+        provider: readSyncNullableStringField(profile, 'provider') ?? null,
+        model: readSyncNullableStringField(profile, 'model') ?? null,
         surfaceType: normalizeSurfaceType(profile.surfaceType, { source, profileId, workspaceId: profileWorkspaceId }),
+        seatScope: normalizeSeatScope(profile.seatScope, { source, profileId, workspaceId: profileWorkspaceId }),
         providerMetadata: profile.providerMetadata && typeof profile.providerMetadata === 'object' && !Array.isArray(profile.providerMetadata)
             ? profile.providerMetadata
             : null,
+        archivedAt: readSyncNullableIsoStringField(profile, 'archivedAt') ?? null,
+        archivedBy: readSyncNullableIdField(profile, 'archivedBy') ?? null,
+        archivedReason: readSyncNullableStringField(profile, 'archivedReason') ?? null,
+        mergedIntoProfileId: readSyncNullableIdField(profile, 'mergedIntoProfileId') ?? null,
+        rosterStateUpdatedAt: readSyncNullableIsoStringField(profile, 'rosterStateUpdatedAt') ?? null,
         createdAt: String(profile.createdAt || '').trim(),
         updatedAt: String(profile.updatedAt || profile.createdAt || '').trim(),
-        lastActiveAt: toNullableTrimmedString(profile.lastActiveAt),
+        lastActiveAt: readSyncNullableIsoStringField(profile, 'lastActiveAt') ?? toNullableTrimmedString(profile.lastActiveAt),
     };
 }
 export function normalizeDocumentReviewSessionSyncPayload(raw, sourceWatermark) {

package/dist/sync/collaborationSyncPayload.test.js

@@ -6,6 +6,11 @@ describe('collaborationSyncPayload', () => {
             return null;
         return String(value).trim();
     };
+    const normalizeSeatScope = (value) => {
+        if (value === undefined || value === null || value === '')
+            return null;
+        return String(value).trim();
+    };
     it('normalizes ai profile sync payloads with workspace and surface type', () => {
         const profile = normalizeAiProfileSyncPayload({
             id: 'profile-1',
@@ -20,11 +25,12 @@ describe('collaborationSyncPayload', () => {
             provider: ' OpenAI ',
             model: ' gpt-5.4 ',
             surfaceType: 'agent',
+            seatScope: 'cloud_metered',
             providerMetadata: { foo: 'bar' },
             createdAt: '2026-04-10T10:00:00.000Z',
             updatedAt: '2026-04-10T11:00:00.000Z',
             lastActiveAt: '2026-04-10T12:00:00.000Z',
-        }, 'workspace-a', normalizeSurfaceType, 'test.ai');
+        }, 'workspace-a', normalizeSurfaceType, normalizeSeatScope, 'test.ai');
         expect(profile).toEqual({
             id: 'profile-1',
             workspaceId: 'workspace-a',
@@ -33,12 +39,19 @@ describe('collaborationSyncPayload', () => {
             username: 'agent',
             icon: 'Bot',
             color: '#111111',
+            avatarUpdatedAt: null,
             description: 'Product coding agent',
             role: 'Implementer',
             provider: 'OpenAI',
             model: 'gpt-5.4',
             surfaceType: 'agent',
+            seatScope: 'cloud_metered',
             providerMetadata: { foo: 'bar' },
+            archivedAt: null,
+            archivedBy: null,
+            archivedReason: null,
+            mergedIntoProfileId: null,
+            rosterStateUpdatedAt: null,
             createdAt: '2026-04-10T10:00:00.000Z',
             updatedAt: '2026-04-10T11:00:00.000Z',
             lastActiveAt: '2026-04-10T12:00:00.000Z',

package/dist/sync/collaborationSyncState.d.ts

@@ -1,5 +1,5 @@
 import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
-import type { WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncTaskEventSnapshot } from './workspaceSyncModel.js';
+import type { WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncEntityEventSnapshot } from './workspaceSyncModel.js';
 type SyncCore = TaskforceCore & TaskforceSyncCapable;
 interface CollaborationSyncStateDeps {
     core: SyncCore;
@@ -7,11 +7,11 @@ interface CollaborationSyncStateDeps {
 export declare function listWorkspaceSyncDocumentReviewSessionsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncDocumentReviewSessionSnapshot[];
 export declare function listWorkspaceSyncDocumentReviewCommentsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncDocumentReviewCommentSnapshot[];
 export declare function listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
-export declare function listWorkspaceSyncTaskEventsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncTaskEventSnapshot[];
+export declare function listWorkspaceSyncTaskEventsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncEntityEventSnapshot[];
 export declare function createCollaborationSyncState(deps: CollaborationSyncStateDeps): {
     listWorkspaceSyncDocumentReviewSessionsSnapshot: (workspaceId?: string) => WorkspaceSyncDocumentReviewSessionSnapshot[];
     listWorkspaceSyncDocumentReviewCommentsSnapshot: (workspaceId?: string) => WorkspaceSyncDocumentReviewCommentSnapshot[];
     listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: (workspaceId?: string) => WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
-    listWorkspaceSyncTaskEventsSnapshot: (workspaceId?: string) => WorkspaceSyncTaskEventSnapshot[];
+    listWorkspaceSyncTaskEventsSnapshot: (workspaceId?: string) => WorkspaceSyncEntityEventSnapshot[];
 };
 export {};

package/dist/sync/collaborationSyncState.js

@@ -52,19 +52,26 @@ export function listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps, works
         && session.baseImageAssetId.length > 0));
 }
 export function listWorkspaceSyncTaskEventsSnapshot(deps, workspaceId = 'default') {
-    return deps.core.listTaskEventsForSync({ workspaceId })
-        .map((event) => ({
-        id: event.id,
-        taskId: event.taskId,
-        workspaceId: event.workspaceId,
-        action: event.action,
-        actor: event.actor,
-        actorType: event.actorType,
-        details: event.details,
-        createdAt: event.createdAt,
-    }))
+    return deps.core.listEntityEventsForSync({ workspaceId })
+        .map((event) => {
+        const entityType = event.entityType === 'initiative' || event.entityType === 'workstream'
+            ? event.entityType
+            : 'task';
+        return {
+            id: event.id,
+            workspaceId: event.workspaceId,
+            entityType,
+            entityId: String(event.entityId || ('taskId' in event ? event.taskId : '') || '').trim(),
+            taskId: entityType === 'task' && 'taskId' in event ? event.taskId : undefined,
+            action: event.action,
+            actor: event.actor,
+            actorType: event.actorType,
+            details: event.details,
+            createdAt: event.createdAt,
+        };
+    })
         .filter((event) => (event.id.length > 0
-        && event.taskId.length > 0
+        && event.entityId.length > 0
         && event.workspaceId.length > 0
         && event.action.length > 0
         && event.createdAt.length > 0));

package/dist/sync/contentSyncPayload.d.ts

@@ -1,4 +1,4 @@
-import type { WorkspaceAssetLinkRole } from '../storage/workspaceAssetStore.js';
+import type { WorkspaceAssetLinkRole, WorkspaceAssetLinkTargetType } from '../storage/workspaceAssetStore.js';
 export interface DocumentSyncPayload {
     path: string;
     updatedAt: string;
@@ -8,6 +8,8 @@ export interface DocumentSyncPayload {
     referenceNumber?: number | null;
     version?: number | null;
     taskId?: string | null;
+    linkTargetType?: WorkspaceAssetLinkTargetType | null;
+    linkTargetId?: string | null;
     logicalName?: string | null;
     caption?: string | null;
     originalFilename?: string | null;
@@ -27,6 +29,8 @@ export interface BinaryAssetSyncPayload {
     mimeType: string;
     referenceNumber?: number | null;
     taskId?: string | null;
+    linkTargetType?: WorkspaceAssetLinkTargetType | null;
+    linkTargetId?: string | null;
     logicalName?: string | null;
     caption?: string | null;
     originalFilename?: string | null;