@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/shared/taskActor.d.ts

@@ -0,0 +1,10 @@
+export interface TaskActor {
+    id: string;
+    kind: 'human' | 'ai';
+    label: string;
+    username: string;
+    icon: string;
+    color: string;
+    isNamed: boolean;
+    meta?: Record<string, unknown>;
+}

package/dist/shared/taskActor.js

@@ -0,0 +1 @@
+export {};

package/dist/sync/collaborationSyncPayload.js

@@ -39,6 +39,10 @@ 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),
         surfaceType: normalizeSurfaceType(profile.surfaceType, { source, profileId, workspaceId: profileWorkspaceId }),
         providerMetadata: profile.providerMetadata && typeof profile.providerMetadata === 'object' && !Array.isArray(profile.providerMetadata)
             ? profile.providerMetadata

package/dist/sync/collaborationSyncPayload.test.js

@@ -15,6 +15,10 @@ describe('collaborationSyncPayload', () => {
             username: ' agent ',
             icon: ' Bot ',
             color: ' #111111 ',
+            description: ' Product coding agent ',
+            role: ' Implementer ',
+            provider: ' OpenAI ',
+            model: ' gpt-5.4 ',
             surfaceType: 'agent',
             providerMetadata: { foo: 'bar' },
             createdAt: '2026-04-10T10:00:00.000Z',
@@ -29,6 +33,10 @@ describe('collaborationSyncPayload', () => {
             username: 'agent',
             icon: 'Bot',
             color: '#111111',
+            description: 'Product coding agent',
+            role: 'Implementer',
+            provider: 'OpenAI',
+            model: 'gpt-5.4',
             surfaceType: 'agent',
             providerMetadata: { foo: 'bar' },
             createdAt: '2026-04-10T10: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 } from './workspaceSyncModel.js';
+import type { WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncTaskEventSnapshot } from './workspaceSyncModel.js';
 type SyncCore = TaskforceCore & TaskforceSyncCapable;
 interface CollaborationSyncStateDeps {
     core: SyncCore;
@@ -7,9 +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 createCollaborationSyncState(deps: CollaborationSyncStateDeps): {
     listWorkspaceSyncDocumentReviewSessionsSnapshot: (workspaceId?: string) => WorkspaceSyncDocumentReviewSessionSnapshot[];
     listWorkspaceSyncDocumentReviewCommentsSnapshot: (workspaceId?: string) => WorkspaceSyncDocumentReviewCommentSnapshot[];
     listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: (workspaceId?: string) => WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
+    listWorkspaceSyncTaskEventsSnapshot: (workspaceId?: string) => WorkspaceSyncTaskEventSnapshot[];
 };
 export {};

package/dist/sync/collaborationSyncState.js

@@ -51,10 +51,29 @@ export function listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps, works
         && session.workspaceId.length > 0
         && 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,
+    }))
+        .filter((event) => (event.id.length > 0
+        && event.taskId.length > 0
+        && event.workspaceId.length > 0
+        && event.action.length > 0
+        && event.createdAt.length > 0));
+}
 export function createCollaborationSyncState(deps) {
     return {
         listWorkspaceSyncDocumentReviewSessionsSnapshot: (workspaceId = 'default') => listWorkspaceSyncDocumentReviewSessionsSnapshot(deps, workspaceId),
         listWorkspaceSyncDocumentReviewCommentsSnapshot: (workspaceId = 'default') => listWorkspaceSyncDocumentReviewCommentsSnapshot(deps, workspaceId),
         listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: (workspaceId = 'default') => listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps, workspaceId),
+        listWorkspaceSyncTaskEventsSnapshot: (workspaceId = 'default') => listWorkspaceSyncTaskEventsSnapshot(deps, workspaceId),
     };
 }

package/dist/sync/contentSyncState.js

@@ -80,8 +80,7 @@ export function hasDocumentSyncMetadataDrift(deps, workspaceId, doc, options) {
             incomingReferenceNumber: normalizedIncomingReference
         });
     }
-    return referenceNumberMismatch
-        || (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
+    return (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
         || existingAsset.version !== normalizedIncomingVersion
         || (existingAsset.documentId || null) !== normalizedIncomingDocumentId
         || (existingAsset.logicalName || null) !== normalizedIncomingLogicalName
@@ -130,8 +129,7 @@ export function hasBinaryAssetSyncMetadataDrift(deps, workspaceId, asset, option
             incomingReferenceNumber: normalizedIncomingReference
         });
     }
-    return referenceNumberMismatch
-        || (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
+    return (allowReferenceNumberReassignment && existingAsset.referenceNumber !== normalizedIncomingReference)
         || (existingAsset.logicalName || null) !== normalizedIncomingLogicalName
         || (existingAsset.originalFilename || null) !== normalizedIncomingFilename
         || (primaryLink?.taskId || null) !== normalizedIncomingTaskId
@@ -535,15 +533,25 @@ export async function loadWorkspaceSyncDocumentPayload(deps, basePath, workspace
     const absolutePath = path.resolve(path.join(root, normalizedPath));
     if (absolutePath !== root && !absolutePath.startsWith(`${root}${path.sep}`))
         return null;
+    const objectStorageClient = deps.getObjectStorageClient();
+    const canonicalAsset = deps.workspaceAssetStore?.getByStorageKey(normalizedPath, workspaceId);
     let content = '';
     let stat = null;
     try {
-        if (!fs.existsSync(absolutePath))
-            return null;
-        stat = fs.statSync(absolutePath);
-        if (!stat.isFile())
-            return null;
-        content = fs.readFileSync(absolutePath, 'utf8');
+        if (canonicalAsset?.kind === 'document' && canonicalAsset.storageProvider === 'r2' && objectStorageClient) {
+            const object = await objectStorageClient.getObject(normalizedPath);
+            if (!object?.body)
+                return null;
+            content = object.body.toString('utf8');
+        }
+        else {
+            if (!fs.existsSync(absolutePath))
+                return null;
+            stat = fs.statSync(absolutePath);
+            if (!stat.isFile())
+                return null;
+            content = fs.readFileSync(absolutePath, 'utf8');
+        }
     }
     catch (error) {
         deps.recordSyncDiagnostic(workspaceId, 'pull', 'Failed to load targeted sync document payload.', {
@@ -560,7 +568,6 @@ export async function loadWorkspaceSyncDocumentPayload(deps, basePath, workspace
             return next;
         })();
     const cached = workspaceCache.get(normalizedPath);
-    const canonicalAsset = deps.workspaceAssetStore?.getByStorageKey(normalizedPath, workspaceId);
     let updatedAt = '';
     if (canonicalAsset?.kind === 'document') {
         updatedAt = resolveCanonicalAssetSyncLinkState(deps, canonicalAsset, workspaceId).effectiveUpdatedAt;
@@ -733,8 +740,10 @@ export async function writeWorkspaceSyncDocument(deps, basePath, doc, workspaceI
             const incomingReferenceNumber = Number.isFinite(Number(doc.referenceNumber))
                 ? Math.max(1, Math.floor(Number(doc.referenceNumber)))
                 : null;
-            const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true
-                || Boolean(existing?.referenceNumber && incomingReferenceNumber && existing.referenceNumber !== incomingReferenceNumber);
+            const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true;
+            const nextReferenceNumber = allowReferenceNumberReassignment
+                ? (incomingReferenceNumber ?? existing?.referenceNumber ?? null)
+                : (existing?.referenceNumber ?? incomingReferenceNumber ?? null);
             const originalFilename = String(doc.originalFilename || existing?.originalFilename || path.basename(normalizedPath) || 'document.md').trim() || 'document.md';
             const asset = deps.workspaceAssetStore.upsertAsset({
                 assetId: String(doc.assetId || existing?.assetId || `asset-${randomUUID().replace(/-/g, '')}`),
@@ -750,7 +759,7 @@ export async function writeWorkspaceSyncDocument(deps, basePath, doc, workspaceI
                 contentSha256: contentHash,
                 sizeBytes: Buffer.byteLength(content, 'utf8'),
                 documentId: String(doc.documentId || existing?.documentId || `doc-${randomUUID().replace(/-/g, '')}`),
-                referenceNumber: incomingReferenceNumber ?? existing?.referenceNumber ?? null,
+                referenceNumber: nextReferenceNumber,
                 version: Number.isFinite(Number(doc.version))
                     ? Math.max(1, Math.floor(Number(doc.version)))
                     : Math.max(1, Number(existing?.version || 0) + 1),
@@ -826,8 +835,10 @@ export async function writeWorkspaceSyncBinaryAsset(deps, basePath, asset, works
         const incomingReferenceNumber = Number.isFinite(Number(asset.referenceNumber))
             ? Math.max(1, Math.floor(Number(asset.referenceNumber)))
             : null;
-        const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true
-            || Boolean(existing?.referenceNumber && incomingReferenceNumber && existing.referenceNumber !== incomingReferenceNumber);
+        const allowReferenceNumberReassignment = options?.allowReferenceNumberReassignment === true;
+        const nextReferenceNumber = allowReferenceNumberReassignment
+            ? (incomingReferenceNumber ?? existing?.referenceNumber ?? null)
+            : (existing?.referenceNumber ?? incomingReferenceNumber ?? null);
         const assetRecord = deps.workspaceAssetStore.upsertAsset({
             assetId: String(asset.assetId || existing?.assetId || `asset-${randomUUID().replace(/-/g, '')}`),
             workspaceId,
@@ -842,7 +853,7 @@ export async function writeWorkspaceSyncBinaryAsset(deps, basePath, asset, works
             contentSha256: createHash('sha256').update(buffer).digest('hex'),
             sizeBytes: buffer.length,
             documentId: null,
-            referenceNumber: incomingReferenceNumber ?? existing?.referenceNumber ?? null,
+            referenceNumber: nextReferenceNumber,
             version: null,
             isLatest: true,
             scanStatus: existing?.scanStatus || 'clean',

package/dist/sync/syncApplyHandlers.d.ts

@@ -1,6 +1,7 @@
 import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
-import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
+import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncChange, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncTaskEventSnapshot, WorkspaceSyncTaskSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
 import type { BinaryAssetSyncPayload, DocumentSyncPayload } from './contentSyncPayload.js';
+import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
 type SyncCore = TaskforceCore & TaskforceSyncCapable;
 type SyncRouteError = Error & {
     code?: string;
@@ -12,7 +13,81 @@ type CreateSyncRouteError = (message: string, details: Record<string, unknown>,
     code?: string;
     statusCode?: number;
 }) => SyncRouteError;
+type NormalizeIncomingAiProfileSurfaceType = (value: unknown, context: {
+    source: string;
+    profileId?: string;
+    workspaceId?: string;
+}) => AiProfileSurfaceType | null;
+type NormalizeTaskEventSyncPayload = (raw: unknown, workspaceId: string, sourceWatermark?: string) => WorkspaceSyncTaskEventSnapshot | null;
+export interface WorkspaceSyncIncomingTaskMutation {
+    archived: boolean;
+    task: WorkspaceSyncTaskSnapshot;
+}
+export interface WorkspaceSyncIncomingTaskApplyModel {
+    upserts: WorkspaceSyncIncomingTaskMutation[];
+    deletes: Map<string, string>;
+}
+export interface WorkspaceSyncIncomingApplyModel {
+    taskMutations: WorkspaceSyncIncomingTaskApplyModel;
+    planning: {
+        incomingTaxonomies: unknown[] | null;
+        incomingTaxonomyState: Record<string, unknown> | null;
+        incomingTaxonomiesUpdatedAt: string;
+        incomingInitiatives: Map<string, WorkspaceSyncInitiativeSnapshot>;
+        incomingWorkstreams: Map<string, WorkspaceSyncWorkstreamSnapshot>;
+    };
+    profiles: {
+        incomingAiProfiles: Map<string, WorkspaceSyncAiProfileSnapshot>;
+    };
+    content: {
+        incomingDocuments: DocumentSyncPayload[];
+        incomingDocumentDeletes: Map<string, string>;
+        incomingAssets: BinaryAssetSyncPayload[];
+        incomingAssetDeletes: Map<string, string>;
+    };
+    collaboration: {
+        incomingDocumentReviewSessions: Map<string, WorkspaceSyncDocumentReviewSessionSnapshot>;
+        incomingDocumentReviewSessionDeletes: Map<string, string>;
+        incomingDocumentReviewComments: Map<string, WorkspaceSyncDocumentReviewCommentSnapshot>;
+        incomingDocumentReviewCommentDeletes: Map<string, string>;
+        incomingAnnotatedAttachmentSessions: Map<string, WorkspaceSyncAnnotatedAttachmentSessionSnapshot>;
+        incomingAnnotatedAttachmentSessionDeletes: Map<string, string>;
+    };
+    taskActivity: {
+        incomingTaskEvents: Map<string, WorkspaceSyncTaskEventSnapshot>;
+    };
+}
+export interface PreparedWorkspaceTaskSyncSnapshot {
+    tasks: WorkspaceSyncTaskSnapshot[];
+    archived: WorkspaceSyncTaskSnapshot[];
+}
 export declare function resolveSyncConflictOrdering(incomingWatermark: string, existingWatermark: string, incomingTieBreak: string, existingTieBreak: string): number;
+export declare function classifyWorkspaceSyncChanges(input: {
+    workspaceId: string;
+    incomingChanges: WorkspaceSyncChange[];
+    normalizeWorkspaceSyncDocumentPath: (rawPath: unknown) => string | null;
+    normalizeTaskAssetPath: (rawPath: unknown) => string | null;
+    normalizeIncomingAiProfileSurfaceType: NormalizeIncomingAiProfileSurfaceType;
+    normalizeTaskEventSyncPayload: NormalizeTaskEventSyncPayload;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+}): WorkspaceSyncIncomingApplyModel;
+export declare function prepareTaskSyncSnapshotApply(input: {
+    core: SyncCore;
+    workspaceId: string;
+    taskMutations: WorkspaceSyncIncomingTaskApplyModel;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+}): PreparedWorkspaceTaskSyncSnapshot;
+export declare function applyTaskSyncDeletes(input: {
+    core: SyncCore;
+    workspaceId: string;
+    taskMutations: WorkspaceSyncIncomingTaskApplyModel;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+}): number;
+export declare function applyPreparedTaskSyncSnapshot(input: {
+    core: SyncCore;
+    workspaceId: string;
+    prepared: PreparedWorkspaceTaskSyncSnapshot;
+}): ReturnType<SyncCore['applyWorkspaceSyncSnapshot']>;
 export declare function applyPlanningSyncChanges(input: {
     core: SyncCore;
     workspaceId: string;
@@ -51,6 +126,10 @@ export declare function applyContentSyncChanges(input: {
     hasBinaryAssetSyncMetadataDrift: (workspaceId: string, asset: BinaryAssetSyncPayload, options?: {
         allowReferenceNumberReassignment?: boolean;
     }) => boolean;
+    getExistingDocument?: (docPath: string, workspaceId: string) => {
+        updatedAt?: string | null;
+        contentHash?: string | null;
+    } | null;
     writeWorkspaceSyncDocument: (basePath: string, doc: DocumentSyncPayload, workspaceId?: string, options?: {
         allowReferenceNumberReassignment?: boolean;
     }) => Promise<void>;
@@ -80,4 +159,11 @@ export declare function applyCollaborationSyncChanges(input: {
     recordSyncDiagnostic: RecordSyncDiagnostic;
     createSyncRouteError: CreateSyncRouteError;
 }): void;
+export declare function applyTaskActivitySyncChanges(input: {
+    core: SyncCore;
+    workspaceId: string;
+    incomingTaskEvents: Map<string, WorkspaceSyncTaskEventSnapshot>;
+    recordSyncDiagnostic: RecordSyncDiagnostic;
+    createSyncRouteError: CreateSyncRouteError;
+}): void;
 export {};