@taskforcehq/taskforce 0.3.304 → 0.3.306

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.js

@@ -1,4 +1,5 @@
 import { serializeTaskForSync } from './taskSyncPayload.js';
+import { aiProfileSyncResourceAdapter, taskSyncResourceAdapter } from './syncResourceAdapters.js';
 export async function buildWorkspacePullFeed(input) {
     const buildStartedAtMs = Date.now();
     const { core, workspaceId, cursor, pageSize, encodeWorkspaceSyncCursor, contentSyncState, collaborationSyncState } = input;
@@ -7,7 +8,7 @@ export async function buildWorkspacePullFeed(input) {
     const taskRows = core.listTasksForSync(workspaceId, syncCursor, dbFetchLimit);
     const upsertEntries = taskRows
         .map((entry) => {
-        const watermark = String(entry.task?.updatedAt || entry.task?.createdAt || '').trim();
+        const watermark = taskSyncResourceAdapter.getWatermark(entry.task);
         const taskId = String(entry.task?.id || '').trim();
         return {
             kind: 'upsert',
@@ -55,10 +56,10 @@ export async function buildWorkspacePullFeed(input) {
         workstream
     }))
         .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.workstream.id.length > 0);
-    const aiProfileEntries = core.listAiProfiles(workspaceId)
+    const aiProfileEntries = core.listAiProfiles(workspaceId, { includeArchived: true })
         .map((profile) => ({
         kind: 'ai-profile',
-        watermark: String(profile.updatedAt || profile.createdAt || '').trim(),
+        watermark: aiProfileSyncResourceAdapter.getWatermark(profile),
         sortId: `ai-profile:${String(profile.id || '').trim()}`,
         profile
     }))

package/dist/sync/workspacePullFeed.test.js

@@ -126,6 +126,7 @@ describe('workspacePullFeed', () => {
                 userId: 'user-1',
                 email: 'person@example.com',
                 displayName: 'Person',
+                avatarUrl: '/api/taskforce/context/users%2Fuser-1%2Fprofile%2Favatar%2Fheadshot.webp',
                 role: 'owner',
                 permissionMode: 'read-write',
                 betaAccess: true,
@@ -167,6 +168,48 @@ describe('workspacePullFeed', () => {
                 displayName: 'Person',
             })
         ]);
+        expect(result.workspaceMembers[0]).not.toHaveProperty('avatarUrl');
+    });
+    it('includes ai-profile upserts with avatar fields in the pull feed', async () => {
+        const core = createCoreMock();
+        core.listAiProfiles = () => [
+            {
+                id: 'ai-profile-1',
+                workspaceId: 'workspace-1',
+                profileToken: 'tfp_test',
+                name: 'Codex',
+                username: 'codex',
+                icon: 'Bot',
+                color: '#0ea5e9',
+                avatarUrl: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fai-profile-1%2Favatar%2Favatar.webp',
+                avatarSourceUrl: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fai-profile-1%2Favatar%2Fsource.webp',
+                createdAt: '2026-04-10T10:00:00.000Z',
+                updatedAt: '2026-04-10T10:05:00.000Z',
+                lastActiveAt: '2026-04-10T10:05:00.000Z'
+            }
+        ];
+        const result = await buildWorkspacePullFeed({
+            core,
+            workspaceId: 'workspace-1',
+            cursor: null,
+            pageSize: 10,
+            encodeWorkspaceSyncCursor: encodeCursor,
+            contentSyncState: createContentSyncStateMock(),
+            collaborationSyncState: createCollaborationSyncStateMock(),
+        });
+        expect(result.changes).toEqual([
+            expect.objectContaining({
+                op: 'ai-profile-upsert',
+                watermark: '2026-04-10T10:05:00.000Z',
+                profile: expect.objectContaining({
+                    id: 'ai-profile-1',
+                    avatarUrl: expect.stringContaining('/api/taskforce/context/'),
+                    avatarSourceUrl: expect.stringContaining('/api/taskforce/context/')
+                })
+            })
+        ]);
+        expect(result.nextCursor).toBe('2026-04-10T10:05:00.000Z|ai-profile:ai-profile-1');
+        expect(result.hasMore).toBe(false);
     });
     it('hydrates document and asset payloads only for entries included in the current page', async () => {
         const core = createCoreMock();

package/dist/sync/workspaceRepair.js

@@ -338,8 +338,9 @@ export function scanWorkspaceRepair(input) {
         for (const asset of assets) {
             const links = input.workspaceAssetStore.listLinksForAsset(asset.assetId, snapshot.workspaceId, { includeDeleted: false });
             for (const link of links) {
-                if (activeTaskIds.has(link.taskId))
+                if (link.targetType === 'task' && link.taskId && activeTaskIds.has(link.taskId))
                     continue;
+                const linkedTargetId = link.targetId;
                 issues.push({
                     code: 'stale_asset_link',
                     entityKind: 'link',
@@ -349,7 +350,9 @@ export function scanWorkspaceRepair(input) {
                     role: link.role,
                     repairable: true,
                     recommendedAction: 'delete-link',
-                    detail: 'Canonical asset link points to a task that no longer exists in this workspace.'
+                    detail: link.targetType === 'task'
+                        ? 'Canonical asset link points to a task that no longer exists in this workspace.'
+                        : `Canonical asset link points to a missing ${link.targetType} target (${linkedTargetId}).`
                 });
             }
         }

package/dist/sync/workspaceSyncModel.d.ts

@@ -3,6 +3,7 @@ import type { DocumentReviewCommentRecord, DocumentReviewSessionStatus } from '.
 import type { AnnotatedAttachmentAnnotation } from '../annotatedAttachments/types.js';
 import type { WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
 import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import { type AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 import { type TaskSyncPayload } from './taskSyncPayload.js';
 export type WorkspaceSyncTaskSnapshot = TaskSyncPayload;
 export interface WorkspaceSyncTaskEventSnapshot {
@@ -23,12 +24,20 @@ export interface WorkspaceSyncAiProfileSnapshot {
     username: string;
     icon: string;
     color: string;
+    avatarUrl?: string | null;
+    avatarSourceUrl?: string | null;
     description?: string | null;
     role?: string | null;
     provider?: string | null;
     model?: string | null;
     surfaceType?: AiProfileSurfaceType | null;
+    seatScope?: AiProfileSeatScope | null;
     providerMetadata?: Record<string, unknown> | null;
+    archivedAt?: string | null;
+    archivedBy?: string | null;
+    archivedReason?: string | null;
+    mergedIntoProfileId?: string | null;
+    rosterStateUpdatedAt?: string | null;
     createdAt: string;
     updatedAt: string;
     lastActiveAt?: string | null;
@@ -118,6 +127,8 @@ export type WorkspaceSyncChange = {
 } | {
     op: 'delete';
     taskId: string;
+    deletedAt?: string;
+    watermark?: string;
 } | {
     op: 'initiative-upsert';
     initiative: WorkspaceSyncInitiativeSnapshot;
@@ -198,6 +209,8 @@ export type WorkspaceSyncChange = {
 export interface WorkspaceSyncPayload {
     changes: WorkspaceSyncChange[];
     currentTaskIds: Set<string>;
+    currentTaskWatermarks?: Map<string, string>;
+    currentTaskChangeKeys?: Map<string, string>;
     deleteTaskIds: Set<string>;
     currentInitiativeIds: Set<string>;
     currentInitiativeWatermarks: Map<string, string>;
@@ -205,6 +218,7 @@ export interface WorkspaceSyncPayload {
     currentWorkstreamWatermarks: Map<string, string>;
     currentAiProfileIds: Set<string>;
     currentAiProfileWatermarks: Map<string, string>;
+    currentAiProfileChangeKeys?: Map<string, string>;
     currentDocumentPaths: Set<string>;
     deleteDocumentPaths: Set<string>;
     currentDocumentWatermarks: Map<string, string>;
@@ -223,6 +237,34 @@ export interface WorkspaceSyncPayload {
     currentTaskEventWatermarks: Map<string, string>;
     /** Watermarks for every task upsert included in this payload (id → updatedAt|createdAt). */
     pushedWatermarks: Map<string, string>;
+    pushedTaskChangeKeys?: Map<string, string>;
+    deltaDiagnostics?: WorkspaceSyncDeltaDiagnostics;
+}
+export type WorkspaceSyncBaselineResetReason = 'missing-baseline' | 'repair-reset' | 'storage-write-failed';
+export interface WorkspaceSyncDomainDeltaDiagnostics {
+    mode: 'none' | 'delta' | 'send-all';
+    reason: WorkspaceSyncBaselineResetReason | 'full-state-domain' | null;
+    currentCount: number;
+    baselineCount: number;
+    changeCount: number;
+}
+export interface WorkspaceSyncDeltaDiagnostics {
+    totalChanges: number;
+    byOp: Record<string, number>;
+    baselineResetReason: WorkspaceSyncBaselineResetReason | null;
+    domains: {
+        tasks: WorkspaceSyncDomainDeltaDiagnostics;
+        initiatives: WorkspaceSyncDomainDeltaDiagnostics;
+        workstreams: WorkspaceSyncDomainDeltaDiagnostics;
+        aiProfiles: WorkspaceSyncDomainDeltaDiagnostics;
+        documents: WorkspaceSyncDomainDeltaDiagnostics;
+        assets: WorkspaceSyncDomainDeltaDiagnostics;
+        documentReviewSessions: WorkspaceSyncDomainDeltaDiagnostics;
+        documentReviewComments: WorkspaceSyncDomainDeltaDiagnostics;
+        annotatedAttachmentSessions: WorkspaceSyncDomainDeltaDiagnostics;
+        taskEvents: WorkspaceSyncDomainDeltaDiagnostics;
+        taxonomy: WorkspaceSyncDomainDeltaDiagnostics;
+    };
 }
 export declare function toWorkspaceSyncTaskSnapshot(task: TaskItem): WorkspaceSyncTaskSnapshot;
 export interface WorkspaceSyncDocumentSnapshot {
@@ -258,6 +300,7 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     archivedTasks: TaskItem[];
     lastPushedTaskIds: Set<string>;
     pendingDeletedTaskIds: Set<string>;
+    pendingDeletedTaskWatermarks?: Map<string, string>;
     initiatives?: InitiativeItem[];
     workstreams?: WorkstreamItem[];
     taxonomies?: unknown[];
@@ -265,6 +308,8 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     aiProfiles?: WorkspaceSyncAiProfileSnapshot[];
     documents?: WorkspaceSyncDocumentSnapshot[];
     assets?: WorkspaceSyncAssetSnapshot[];
+    currentDocumentPaths?: Iterable<string>;
+    currentAssetPaths?: Iterable<string>;
     documentReviewSessions?: WorkspaceSyncDocumentReviewSessionSnapshot[];
     documentReviewComments?: WorkspaceSyncDocumentReviewCommentSnapshot[];
     annotatedAttachmentSessions?: WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
@@ -286,6 +331,7 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     lastPushedAnnotatedAttachmentSessionIds?: Set<string>;
     lastPushedAnnotatedAttachmentSessionWatermarks?: Map<string, string>;
     lastPushedTaskEventWatermarks?: Map<string, string>;
+    baselineResetReason?: WorkspaceSyncBaselineResetReason | null;
     /**
      * Watermark (updatedAt|createdAt) of each task as of its last successful push.
      * When provided, only tasks whose watermark differs from this map are included
@@ -293,6 +339,8 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
      * Absent or empty map = include all tasks (first-push / full-sync behaviour).
      */
     lastPushedWatermarks?: Map<string, string>;
+    lastPushedTaskChangeKeys?: Map<string, string>;
+    lastPushedAiProfileChangeKeys?: Map<string, string>;
 }): WorkspaceSyncPayload;
 export declare function buildWorkspaceSyncSignatureModel(input: {
     workspaceId: string;