@taskforcehq/taskforce 0.3.300 → 0.3.302

package/dist/core/AiProfileService.js

@@ -184,10 +184,15 @@ export function resolveAiProfileService(deps, input) {
         if (!existingRow) {
             throw deps.createRuleError('AI profile token is invalid for this workspace', 404, 'AI_PROFILE_NOT_FOUND');
         }
+        const existingProfile = deps.aiProfileRowToRecord(existingRow);
         const nextName = name;
         const nextUsername = deps.normalizeAiProfileUsername(undefined, nextName);
-        const nextIcon = deps.normalizeAiProfileIcon(input.icon);
-        const nextColor = deps.normalizeAiProfileColor(input.color);
+        const nextIcon = input.icon === undefined
+            ? existingProfile.icon
+            : deps.normalizeAiProfileIcon(input.icon);
+        const nextColor = input.color === undefined
+            ? existingProfile.color
+            : deps.normalizeAiProfileColor(input.color);
         const nextDescription = normalizeOptionalProfileField(input.description);
         const nextRole = normalizeOptionalProfileField(input.role);
         const nextProvider = normalizeOptionalProfileField(input.provider);

package/dist/core/AiProfiles.test.js

@@ -130,6 +130,25 @@ describe('TaskforceCore ai profiles', () => {
         expect(second.profile.provider).toBe('Anthropic');
         expect(second.profile.model).toBe('claude-sonnet');
     });
+    it('preserves ai profile icon and color when re-resolved without those fields', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            icon: 'Sparkles',
+            color: '#0ea5e9'
+        });
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex 2',
+            profileToken: first.profile.profileToken
+        });
+        expect(second.profile.icon).toBe('Sparkles');
+        expect(second.profile.color).toBe('#0ea5e9');
+    });
     it('clears ai profile surfaceType when re-resolved with null or an empty string', () => {
         const projectRoot = createProjectRoot();
         createdRoots.push(projectRoot);

package/dist/core/SyncReconciliationService.d.ts

@@ -21,6 +21,7 @@ export interface SyncReconciliationServiceDeps {
         persistBackup?: boolean;
         workspaceId?: string;
         allowClientProvidedId?: boolean;
+        preferIncomingReferenceNumberOnConflict?: boolean;
         skipRecompute?: boolean;
         syncUpdatedAt?: string;
         actorRef?: string;
@@ -28,6 +29,7 @@ export interface SyncReconciliationServiceDeps {
     }) => TaskItem;
     updateTask: (id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        preferIncomingReferenceNumberOnConflict?: boolean;
         skipRecompute?: boolean;
         syncUpdatedAt?: string;
         actorRef?: string;

package/dist/core/SyncReconciliationService.js

@@ -198,6 +198,7 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
             createdBy: sourceTask.createdBy === undefined ? existing?.createdBy : sourceTask.createdBy,
             assignee: sourceTask.assignee === undefined ? existing?.assignee : sourceTask.assignee,
             referenceNumber: sourceTask.referenceNumber === undefined ? existing?.referenceNumber : sourceTask.referenceNumber,
+            localReferenceNumber: sourceTask.referenceNumber === undefined ? existing?.localReferenceNumber : null,
             scheduledDate: sourceTask.scheduledDate === undefined ? existing?.scheduledDate : sourceTask.scheduledDate,
             dueDate: sourceTask.dueDate === undefined ? existing?.dueDate : sourceTask.dueDate,
             scheduledWeekKey: sourceTask.scheduledWeekKey === undefined ? existing?.scheduledWeekKey : sourceTask.scheduledWeekKey,
@@ -228,6 +229,7 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
                     persistBackup: false,
                     workspaceId: normalizedWorkspaceId,
                     allowClientProvidedId: true,
+                    preferIncomingReferenceNumberOnConflict: true,
                     skipRecompute: true,
                     syncUpdatedAt: incomingUpdatedAt,
                     skipTaskEvents: true
@@ -244,6 +246,7 @@ export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
             try {
                 updatedTask = deps.updateTask(taskId, taskPatch, normalizedWorkspaceId, {
                     persistBackup: false,
+                    preferIncomingReferenceNumberOnConflict: true,
                     skipRecompute: true,
                     syncUpdatedAt: incomingUpdatedAt,
                     skipTaskEvents: true

package/dist/core/TaskAuditTimeline.test.js

@@ -92,6 +92,46 @@ describe('TaskforceCore task audit timeline', () => {
             cleanup();
         }
     });
+    it('suppresses task events for autosave-style updates when skipTaskEvents is true', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const task = core.createTask({ title: 'Autosave task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
+            core.updateTask(task.id, { description: 'Draft body' }, 'workspace-a', {
+                actorRef: 'user',
+                skipTaskEvents: true
+            });
+            const events = core.listTaskEvents(task.id, 'workspace-a');
+            const hydrated = core.getTask(task.id, 'workspace-a');
+            expect(events.map((event) => event.action)).toEqual(['task-created']);
+            expect(hydrated?.description).toBe('Draft body');
+            expect(hydrated?.activity?.some((item) => item.type === 'event' && item.event.action === 'task-updated')).toBe(false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('captures assignment changes in the core task update event details', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const task = core.createTask({ title: 'Assignment audit task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
+            core.updateTask(task.id, { assignee: 'member-1' }, 'workspace-a', { actorRef: 'user' });
+            const assignmentEvent = core.listTaskEvents(task.id, 'workspace-a').find((event) => event.action === 'task-updated' && event.details?.changes?.assignee);
+            expect(assignmentEvent).toEqual(expect.objectContaining({
+                action: 'task-updated',
+                details: {
+                    changes: {
+                        assignee: {
+                            from: 'unassigned',
+                            to: 'member-1',
+                        },
+                    },
+                },
+            }));
+        }
+        finally {
+            cleanup();
+        }
+    });
     it('repairs legacy comments tables so raw submitted authors can be stored', () => {
         const { core, cleanup } = makeCore();
         try {

package/dist/core/Taskforce.d.ts

@@ -86,6 +86,7 @@ export interface TaskActor {
 export interface TaskItem {
     id: string;
     referenceNumber?: number | null;
+    localReferenceNumber?: number | null;
     referenceLabel?: string;
     title: string;
     description: string | null;
@@ -367,9 +368,24 @@ interface UserIdentityRecord {
     userId: string;
     email: string;
     displayName?: string | null;
+    avatarUrl?: string | null;
     systemRole?: SystemRole;
     betaAccess?: boolean;
 }
+interface UserAvatarUploadDraftRecord {
+    draftId: string;
+    userId: string;
+    storageKey: string;
+    mimeType: string;
+    originalFilename: string;
+    sizeBytes: number;
+    storageProvider: 'local' | 'r2' | 'external';
+    finalizedAt?: string | null;
+    consumedAt?: string | null;
+    discardedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
 interface WorkspaceUserRecord {
     userId: string;
     email: string;
@@ -476,6 +492,8 @@ interface CreateTaskOptions {
     persistBackup?: boolean;
     workspaceId?: string;
     allowClientProvidedId?: boolean;
+    provisionalLocalReference?: boolean;
+    preferIncomingReferenceNumberOnConflict?: boolean;
     skipRecompute?: boolean;
     syncUpdatedAt?: string;
     actorRef?: string;
@@ -971,7 +989,9 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     private rowToWorkstream;
     private rowToChecklistItem;
     private sanitizeTaskReferenceNumber;
+    private getTaskReferencePolicyDeps;
     private getTaskByReferenceNumber;
+    private getTaskByLocalReferenceNumber;
     resolveTaskIdentifier(value: string, workspaceId?: string): TaskItem | null;
     getInitiative(id: string, workspaceId?: string): InitiativeItem | null;
     listInitiatives(workspaceId?: string): InitiativeItem[];
@@ -989,6 +1009,15 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     upsertWorkstreamForSync(workstream: WorkstreamItem, workspaceId?: string | null): WorkstreamItem;
     listChecklistItems(taskId: string, workspaceId?: string): ChecklistItem[];
     replaceChecklistItems(taskId: string, items: Array<Partial<ChecklistItem>>, workspaceId?: string): ChecklistItem[];
+    private getTaskReferenceSequenceValue;
+    private getLocalTaskReferenceSequenceValue;
+    private getMaxTaskReferenceNumber;
+    private getMaxLocalTaskReferenceNumber;
+    private persistTaskReferenceSequence;
+    private persistLocalTaskReferenceSequence;
+    private allocateNextTaskReferenceNumber;
+    private allocateNextLocalTaskReferenceNumber;
+    private relocateTaskReferenceConflict;
     private reserveTaskReferenceNumber;
     private reserveGenericReferenceNumber;
     private reserveInitiativeReferenceNumber;
@@ -1081,7 +1110,25 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     }): UserAccessRecord;
     resolveUserAccess(userId: string, workspaceId: string, fallbackRole?: AccessRole): UserAccessRecord | null;
     resolveUserIdentity(userId: string): UserIdentityRecord | null;
+    updateUserProfile(userId: string, input: {
+        displayName: string;
+        avatarUrl?: string | null;
+    }): UserIdentityRecord | null;
     updateUserDisplayName(userId: string, displayName: string): UserIdentityRecord | null;
+    createUserAvatarUploadDraft(input: {
+        userId: string;
+        draftId: string;
+        storageKey: string;
+        mimeType: string;
+        originalFilename: string;
+        sizeBytes: number;
+        storageProvider?: 'local' | 'r2' | 'external';
+    }): UserAvatarUploadDraftRecord;
+    getUserAvatarUploadDraft(userId: string, draftId: string): UserAvatarUploadDraftRecord | null;
+    markUserAvatarUploadDraftFinalized(userId: string, draftId: string): UserAvatarUploadDraftRecord | null;
+    markUserAvatarUploadDraftConsumed(userId: string, draftId: string): UserAvatarUploadDraftRecord | null;
+    discardUserAvatarUploadDraft(userId: string, draftId: string): UserAvatarUploadDraftRecord | null;
+    cleanupStaleUserAvatarUploadDrafts(userId: string, olderThanIso: string): UserAvatarUploadDraftRecord[];
     getSystemRole(userId: string): SystemRole;
     getUserBetaAccess(userId: string): boolean;
     countSystemAdmins(): number;
@@ -1602,9 +1649,11 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         validateOnly?: boolean;
         workspaceId?: string;
         allowClientProvidedId?: boolean;
+        provisionalLocalReference?: boolean;
     }): BulkCreateTaskResult;
     updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        preferIncomingReferenceNumberOnConflict?: boolean;
         skipRecompute?: boolean;
         syncUpdatedAt?: string;
         actorRef?: string;

package/dist/core/Taskforce.ids.test.js

@@ -80,6 +80,139 @@ describe('TaskforceCore id policy', () => {
             cleanup();
         }
     });
+    it('assigns provisional local task references without consuming canonical task references', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const provisionalFirst = core.createTask({ title: 'Offline first' }, {
+                workspaceId: 'workspace-a',
+                provisionalLocalReference: true
+            });
+            const provisionalSecond = core.createTask({ title: 'Offline second' }, {
+                workspaceId: 'workspace-a',
+                provisionalLocalReference: true
+            });
+            const canonical = core.createTask({ title: 'Cloud-backed task' }, { workspaceId: 'workspace-a' });
+            expect(provisionalFirst.referenceNumber).toBeNull();
+            expect(provisionalFirst.localReferenceNumber).toBe(1);
+            expect(provisionalFirst.referenceLabel).toBe('LT-1');
+            expect(provisionalSecond.referenceNumber).toBeNull();
+            expect(provisionalSecond.localReferenceNumber).toBe(2);
+            expect(provisionalSecond.referenceLabel).toBe('LT-2');
+            expect(canonical.referenceNumber).toBe(1);
+            expect(canonical.localReferenceNumber).toBeNull();
+            expect(canonical.referenceLabel).toBe('T-1');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('replaces a provisional local reference with a canonical cloud reference during sync apply', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const provisional = core.createTask({ title: 'Offline draft' }, {
+                workspaceId: 'workspace-a',
+                provisionalLocalReference: true
+            });
+            expect(provisional.referenceLabel).toBe('LT-1');
+            const syncResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: provisional.id,
+                        title: 'Offline draft',
+                        status: 'task',
+                        referenceNumber: 7,
+                        updatedAt: '2099-04-10T17:00:00.000Z'
+                    }
+                ]
+            }, 'workspace-a');
+            expect(syncResult.updated).toBe(1);
+            expect(core.getTask(provisional.id, 'workspace-a')).toEqual(expect.objectContaining({
+                referenceNumber: 7,
+                localReferenceNumber: null,
+                referenceLabel: 'T-7'
+            }));
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('preserves provisional local references across core reloads', () => {
+        const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-id-reload-test-'));
+        const storagePath = path.join(projectRoot, '.taskforce');
+        const firstCore = new TaskforceCore({ projectRoot, storagePath });
+        try {
+            const provisional = firstCore.createTask({ title: 'Offline draft' }, {
+                workspaceId: 'workspace-a',
+                provisionalLocalReference: true
+            });
+            expect(provisional.referenceNumber).toBeNull();
+            expect(provisional.localReferenceNumber).toBe(1);
+            firstCore.close();
+            const reloadedCore = new TaskforceCore({ projectRoot, storagePath });
+            try {
+                const reloadedTask = reloadedCore.getTask(provisional.id, 'workspace-a');
+                expect(reloadedTask).toEqual(expect.objectContaining({
+                    referenceNumber: null,
+                    localReferenceNumber: 1,
+                    referenceLabel: 'LT-1'
+                }));
+            }
+            finally {
+                reloadedCore.close();
+            }
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('lets the incoming synced task keep its preferred reference and renumbers the local incumbent', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const localTask = core.createTask({ title: 'Local task' }, { workspaceId: 'workspace-a' });
+            const syncResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: 'task-sync-imported-collision',
+                        title: 'Remote task',
+                        status: 'task',
+                        referenceNumber: localTask.referenceNumber,
+                        createdAt: '2026-04-10T15:00:00.000Z',
+                        updatedAt: '2026-04-10T15:00:00.000Z',
+                    }
+                ]
+            }, 'workspace-a');
+            expect(syncResult.created).toBe(1);
+            expect(core.getTask(localTask.id, 'workspace-a')?.referenceLabel).toBe('T-2');
+            expect(core.getTask('task-sync-imported-collision', 'workspace-a')?.referenceLabel).toBe('T-1');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('lets incoming synced updates claim the preferred reference and renumbers the displaced task', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const first = core.createTask({ title: 'First' }, { workspaceId: 'workspace-a' });
+            const second = core.createTask({ title: 'Second' }, { workspaceId: 'workspace-a' });
+            const syncResult = core.applyWorkspaceSyncSnapshot({
+                tasks: [
+                    {
+                        id: second.id,
+                        title: 'Second',
+                        status: 'task',
+                        referenceNumber: first.referenceNumber,
+                        updatedAt: '2099-04-11T16:00:00.000Z',
+                    }
+                ]
+            }, 'workspace-a');
+            expect(syncResult.updated).toBe(1);
+            expect(core.getTask(first.id, 'workspace-a')?.referenceLabel).toBe('T-3');
+            expect(core.getTask(second.id, 'workspace-a')?.referenceLabel).toBe('T-1');
+        }
+        finally {
+            cleanup();
+        }
+    });
     it('resolves task identifiers by task reference or internal id', () => {
         const { core, cleanup } = makeCore();
         try {