@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/compat/workspaceSyncCompat.js

@@ -8,6 +8,48 @@ function normalizeSetupIntent(value) {
     const normalized = String(value || '').trim().toLowerCase();
     return normalized === 'attach-cloud-import' ? 'attach-cloud-import' : null;
 }
+function normalizeWatermarkEntry(value) {
+    if (!Array.isArray(value) || value.length < 2)
+        return null;
+    const key = String(value[0] || '').trim();
+    const watermark = String(value[1] || '').trim();
+    if (!key || !watermark)
+        return null;
+    return [key, watermark];
+}
+function normalizeIdEntries(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((entry) => String(entry || '').trim())
+        .filter((entry) => entry.length > 0);
+}
+function normalizePushBaseline(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const raw = value;
+    const normalizeEntries = (field) => (Array.isArray(raw[field])
+        ? raw[field]
+            .map((entry) => normalizeWatermarkEntry(entry))
+            .filter((entry) => Array.isArray(entry))
+        : []);
+    return {
+        taskIds: normalizeIdEntries(raw.taskIds),
+        taskWatermarks: normalizeEntries('taskWatermarks'),
+        taskChangeKeys: normalizeEntries('taskChangeKeys'),
+        initiativeWatermarks: normalizeEntries('initiativeWatermarks'),
+        workstreamWatermarks: normalizeEntries('workstreamWatermarks'),
+        aiProfileWatermarks: normalizeEntries('aiProfileWatermarks'),
+        aiProfileChangeKeys: normalizeEntries('aiProfileChangeKeys'),
+        documentWatermarks: normalizeEntries('documentWatermarks'),
+        assetWatermarks: normalizeEntries('assetWatermarks'),
+        documentReviewSessionWatermarks: normalizeEntries('documentReviewSessionWatermarks'),
+        documentReviewCommentWatermarks: normalizeEntries('documentReviewCommentWatermarks'),
+        annotatedAttachmentSessionWatermarks: normalizeEntries('annotatedAttachmentSessionWatermarks'),
+        taskEventWatermarks: normalizeEntries('taskEventWatermarks'),
+        taxonomyStateFingerprint: String(raw.taxonomyStateFingerprint || '').trim()
+    };
+}
 function resolveLegacyPhase(input, base) {
     const enabled = Boolean(input.enabled ?? input.cloudSyncEnabled);
     if (!enabled)
@@ -55,7 +97,8 @@ export function normalizeWorkspaceSyncStateCompat(rawState) {
         lastPullAt: normalizeTimestamp(state.lastPullAt),
         lastPushAt: normalizeTimestamp(state.lastPushAt),
         lastSyncedAt: normalizeTimestamp(state.lastSyncedAt),
-        lastErrorMessage: normalizedLastErrorMessage
+        lastErrorMessage: normalizedLastErrorMessage,
+        pushBaseline: normalizePushBaseline(state.pushBaseline)
     };
     normalized.phase = resolveLegacyPhase(state, normalized);
     if (!normalized.enabled) {
@@ -77,7 +120,8 @@ export function normalizeWorkspaceSyncStateCompat(rawState) {
         || normalizeTimestamp(state.lastPullAt) !== normalized.lastPullAt
         || normalizeTimestamp(state.lastPushAt) !== normalized.lastPushAt
         || normalizeTimestamp(state.lastSyncedAt) !== normalized.lastSyncedAt
-        || normalizedLastErrorMessage !== normalized.lastErrorMessage;
+        || normalizedLastErrorMessage !== normalized.lastErrorMessage
+        || JSON.stringify(normalizePushBaseline(state.pushBaseline)) !== JSON.stringify(normalized.pushBaseline);
     return {
         state: normalized,
         changed

package/dist/compat/workspaceSyncCompat.test.js

@@ -14,11 +14,13 @@ describe('workspaceSyncCompat', () => {
             version: 2,
             enabled: false,
             phase: 'idle',
+            setupIntent: null,
             pullCursor: null,
             lastPullAt: null,
             lastPushAt: null,
             lastSyncedAt: null,
-            lastErrorMessage: null
+            lastErrorMessage: null,
+            pushBaseline: null
         });
     });
     it('maps legacy local bootstrap state to provision-local phase', () => {
@@ -84,4 +86,39 @@ describe('workspaceSyncCompat', () => {
         });
         expect(result.state.lastErrorMessage).toBeNull();
     });
+    it('normalizes pushBaseline snapshots when present in raw state', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            version: 2,
+            enabled: true,
+            phase: 'active',
+            pushBaseline: {
+                taskIds: ['task-1'],
+                taskWatermarks: [['task-1', '2026-03-15T15:00:00.000Z']],
+                initiativeWatermarks: [],
+                workstreamWatermarks: [],
+                aiProfileWatermarks: [['profile-1', '2026-03-15T15:05:00.000Z']],
+                documentWatermarks: [],
+                assetWatermarks: [],
+                documentReviewSessionWatermarks: [],
+                documentReviewCommentWatermarks: [],
+                annotatedAttachmentSessionWatermarks: [],
+                taskEventWatermarks: [],
+                taxonomyStateFingerprint: 'fingerprint-1'
+            }
+        });
+        expect(result.state.pushBaseline).toEqual({
+            taskIds: ['task-1'],
+            taskWatermarks: [['task-1', '2026-03-15T15:00:00.000Z']],
+            initiativeWatermarks: [],
+            workstreamWatermarks: [],
+            aiProfileWatermarks: [['profile-1', '2026-03-15T15:05:00.000Z']],
+            documentWatermarks: [],
+            assetWatermarks: [],
+            documentReviewSessionWatermarks: [],
+            documentReviewCommentWatermarks: [],
+            annotatedAttachmentSessionWatermarks: [],
+            taskEventWatermarks: [],
+            taxonomyStateFingerprint: 'fingerprint-1'
+        });
+    });
 });

package/dist/components/activity/EntityActivityTimeline.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { type TaskEventValueFormatter } from '../../utils/taskActivity';
+import type { EntityActivityItem, TaskActor } from '../../types';
+export type ActivityActorPresentation = {
+    kind: 'member' | 'agent' | 'system';
+    label: string;
+    color?: string;
+    ActorIcon: React.ComponentType<{
+        size?: number;
+        strokeWidth?: number;
+    }>;
+};
+export declare function EntityActivityTimeline({ activity, comments, formatFieldValue, resolveActorPresentation, onOpenTaskById, emptyMessage, listClassName, emptyClassName, endRef, }: {
+    activity?: EntityActivityItem[];
+    comments?: Array<{
+        id: string;
+        author: string;
+        text: string;
+        timestamp: string;
+        actor?: TaskActor | null;
+    }>;
+    formatFieldValue?: TaskEventValueFormatter;
+    resolveActorPresentation: (input: {
+        actorId?: string | null;
+        actorType?: 'human' | 'ai' | 'system' | null;
+        actorProfile?: TaskActor | null;
+        fallbackKind?: 'member' | 'agent' | 'system';
+    }) => ActivityActorPresentation;
+    onOpenTaskById?: (taskId: string) => void;
+    emptyMessage?: string;
+    listClassName?: string;
+    emptyClassName?: string;
+    endRef?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/activity/EntityActivityTimeline.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Markdown } from '../ui/Markdown';
+import { formatDate } from '../../utils/formatting';
+import { getEntityActivityItems, getEntityEventPrimaryChangeField, summarizeEntityEvent, summarizeTaskChange, } from '../../utils/taskActivity';
+import timelineStyles from './EntityActivityTimeline.module.css';
+function hexToRgba(hex, opacity) {
+    const normalized = hex.replace('#', '').trim();
+    if (normalized.length !== 3 && normalized.length !== 6)
+        return '';
+    const expanded = normalized.length === 3
+        ? normalized.split('').map((part) => part + part).join('')
+        : normalized;
+    const int = Number.parseInt(expanded, 16);
+    if (Number.isNaN(int))
+        return '';
+    const red = (int >> 16) & 255;
+    const green = (int >> 8) & 255;
+    const blue = int & 255;
+    return `rgba(${red}, ${green}, ${blue}, ${opacity})`;
+}
+export function EntityActivityTimeline({ activity, comments, formatFieldValue, resolveActorPresentation, onOpenTaskById, emptyMessage = 'No activity yet.', listClassName, emptyClassName, endRef, }) {
+    const items = React.useMemo(() => getEntityActivityItems({ activity, comments }), [activity, comments]);
+    return (_jsxs("div", { className: [timelineStyles.thread, listClassName].filter(Boolean).join(' '), children: [items.length === 0 ? (_jsx("div", { className: [timelineStyles.empty, emptyClassName].filter(Boolean).join(' '), children: emptyMessage })) : null, items.map((item) => {
+                if (item.type === 'comment') {
+                    const actorPresentation = resolveActorPresentation({
+                        actorId: item.comment.author,
+                        actorType: item.comment.actor?.kind === 'ai'
+                            ? 'ai'
+                            : item.comment.actor?.kind === 'human'
+                                ? 'human'
+                                : null,
+                        actorProfile: item.comment.actor || null,
+                    });
+                    const commentKind = actorPresentation.kind === 'agent' ? 'agent' : 'member';
+                    const { ActorIcon } = actorPresentation;
+                    const authorColor = actorPresentation.color;
+                    const commentAccentStyle = authorColor && hexToRgba(authorColor, 0.35)
+                        ? {
+                            background: `linear-gradient(135deg, ${hexToRgba(authorColor, 0.18)} 0%, ${hexToRgba(authorColor, 0.1)} 100%)`,
+                            borderColor: hexToRgba(authorColor, 0.35),
+                        }
+                        : undefined;
+                    return (_jsxs("div", { className: [
+                            timelineStyles.item,
+                            timelineStyles.comment,
+                            commentKind === 'agent' ? timelineStyles.commentAgent : timelineStyles.commentMember,
+                        ].join(' '), children: [_jsxs("div", { className: timelineStyles.header, children: [_jsxs("span", { className: timelineStyles.author, style: authorColor ? { color: authorColor } : undefined, children: [_jsx(ActorIcon, { size: 12, strokeWidth: 1.5 }), actorPresentation.label] }), _jsx("span", { className: timelineStyles.time, children: formatDate(item.comment.timestamp, {
+                                            month: 'short',
+                                            day: 'numeric',
+                                            hour: '2-digit',
+                                            minute: '2-digit',
+                                        }) })] }), _jsx("div", { className: timelineStyles.commentText, style: commentAccentStyle, children: _jsx(Markdown, { onTaskIdClick: onOpenTaskById, children: item.comment.text }) })] }, item.id));
+                }
+                const actorPresentation = resolveActorPresentation({
+                    actorId: item.event.actor,
+                    actorType: item.event.actorType,
+                    actorProfile: item.event.actorProfile || null,
+                    fallbackKind: 'system',
+                });
+                const { ActorIcon } = actorPresentation;
+                const authorColor = actorPresentation.color;
+                const changeEntries = Object.entries(item.event.details?.changes || {});
+                const primaryChangeField = getEntityEventPrimaryChangeField(item.event);
+                const displayedChangeEntries = changeEntries.length > 1 && primaryChangeField
+                    ? changeEntries.filter(([field]) => field !== primaryChangeField)
+                    : changeEntries.length > 1
+                        ? changeEntries
+                        : [];
+                return (_jsxs("div", { className: [
+                        timelineStyles.item,
+                        timelineStyles.event,
+                        actorPresentation.kind === 'system' ? timelineStyles.eventSystem : '',
+                    ].filter(Boolean).join(' '), children: [_jsxs("div", { className: [timelineStyles.header, timelineStyles.eventHeader].join(' '), children: [_jsxs("span", { className: timelineStyles.author, style: authorColor ? { color: authorColor } : undefined, children: [_jsx(ActorIcon, { size: 12, strokeWidth: 1.5 }), actorPresentation.label] }), _jsx("span", { className: timelineStyles.time, children: formatDate(item.event.createdAt, {
+                                        month: 'short',
+                                        day: 'numeric',
+                                        hour: '2-digit',
+                                        minute: '2-digit',
+                                    }) })] }), _jsxs("div", { className: timelineStyles.eventText, children: [_jsx("div", { children: summarizeEntityEvent(item.event, formatFieldValue) }), displayedChangeEntries.length > 0 ? (_jsx("div", { className: timelineStyles.eventChanges, children: displayedChangeEntries.map(([field, change]) => (_jsx("div", { className: timelineStyles.eventChange, children: summarizeTaskChange(field, change, formatFieldValue) }, field))) })) : null] })] }, item.id));
+            }), _jsx("div", { ref: endRef })] }));
+}

package/dist/components/context/ContextAttachmentManager.d.ts

@@ -0,0 +1,14 @@
+import type { AttachmentItem } from '../../types';
+export type ContextAttachmentOwnerType = 'task' | 'initiative' | 'workstream';
+export interface ContextAttachmentManagerProps {
+    ownerType?: ContextAttachmentOwnerType;
+    ownerId?: string | null;
+    ownerReferenceLabel?: string | null;
+    workspaceId?: string | null;
+    apiBaseUrl?: string;
+    attachments: Array<string | AttachmentItem>;
+    onAddAttachment: (file: AttachmentItem) => void;
+    onRemoveAttachment: (index: number) => void;
+    onUpdateAttachmentCaption: (index: number, caption: string) => void;
+}
+export declare function ContextAttachmentManager(props: ContextAttachmentManagerProps): import("react/jsx-runtime").JSX.Element;