npm - @taskforcehq/taskforce - Versions diffs - 0.3.328 → 0.3.330 - Mend

@taskforcehq/taskforce 0.3.328 → 0.3.330

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (485) hide show

package/dist/ui/branding/logos/letterhead_dark.png ADDED Viewed

Binary file

package/dist/ui/branding/logos/letterhead_light.png ADDED Viewed

Binary file

package/dist/ui/branding/logos/signature_dark.png ADDED Viewed

Binary file

package/dist/ui/branding/logos/signature_light.png ADDED Viewed

Binary file

package/dist/ui/index.html CHANGED Viewed

@@ -8,13 +8,13 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/favicon/favicon-16x16.png" />
     <link rel="apple-touch-icon" href="/taskforce/favicon/apple-touch-icon.png" />
     <title>Taskforce</title>
-    <script type="module" crossorigin src="/taskforce/assets/index-BUplSsv_.js"></script>
+    <script type="module" crossorigin src="/taskforce/assets/index-CTsDBaef.js"></script>
     <link rel="modulepreload" crossorigin href="/taskforce/assets/vendor-react-CKJs5o3c.js">
-    <link rel="modulepreload" crossorigin href="/taskforce/assets/vendor-icons-BkFLXavV.js">
+    <link rel="modulepreload" crossorigin href="/taskforce/assets/vendor-icons-Bsq-mcEn.js">
     <link rel="modulepreload" crossorigin href="/taskforce/assets/vendor-markdown-_lhNCyq-.js">
     <link rel="modulepreload" crossorigin href="/taskforce/assets/vendor-dnd-CJ-AjP-Y.js">
     <link rel="modulepreload" crossorigin href="/taskforce/assets/vendor-router-AqJMU8Lz.js">
-    <link rel="stylesheet" crossorigin href="/taskforce/assets/index-gz2EXuoK.css">
+    <link rel="stylesheet" crossorigin href="/taskforce/assets/index-BZ-hdZSk.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/utils/aiProfileDefaultLogo.js CHANGED Viewed

@@ -1,38 +1,6 @@
-import antigravityLogo from '../assets/ai-profile-clients/antigravity.png';
-import chatgptLogo from '../assets/ai-profile-clients/chatgpt.svg';
-import claudeChatLogo from '../assets/ai-profile-clients/claude-chat.svg';
-import claudeCodeLogo from '../assets/ai-profile-clients/claude-code.svg';
-import clineLogo from '../assets/ai-profile-clients/cline.svg';
-import codexLogo from '../assets/ai-profile-clients/codex.svg';
-import cursorLogo from '../assets/ai-profile-clients/cursor.svg';
-import geminiLogo from '../assets/ai-profile-clients/gemini-cli-icon.png';
-import geminiChatLogo from '../assets/ai-profile-clients/gemini.svg';
-import grokLogo from '../assets/ai-profile-clients/grok.svg';
-import kiroLogo from '../assets/ai-profile-clients/kiro.svg';
-import mistralLogo from '../assets/ai-profile-clients/mistral.svg';
-import perplexityLogo from '../assets/ai-profile-clients/perplexity.svg';
-import vscodeLogo from '../assets/ai-profile-clients/vscode.svg';
-import windsurfLogo from '../assets/ai-profile-clients/windsurf.svg';
 import { getMcpClientRegistryEntry } from '../mcp/clientRegistry.js';
 import { isTaskforceManagedAiProfile } from '../shared/aiProfileAvatarEligibility.js';
-const LOGO_URLS = {
-    antigravity: antigravityLogo,
-    'chatgpt-desktop': chatgptLogo,
-    'claude-code': claudeCodeLogo,
-    'claude-chat': claudeChatLogo,
-    'grok-chat': grokLogo,
-    'gemini-chat': geminiChatLogo,
-    'mistral-chat': mistralLogo,
-    'perplexity-chat': perplexityLogo,
-    cline: clineLogo,
-    codex: codexLogo,
-    cursor: cursorLogo,
-    'gemini-cli': geminiLogo,
-    grok: grokLogo,
-    kiro: kiroLogo,
-    vscode: vscodeLogo,
-    windsurf: windsurfLogo,
-};
+import { getProductLogoUrl } from './productLogoRegistry.js';
 export function getAiProfileDefaultLogoUrl(profile) {
     if (!profile || isTaskforceManagedAiProfile(profile))
         return '';
@@ -42,7 +10,7 @@ export function getAiProfileDefaultLogoUrl(profile) {
         : null;
     const registryEntry = getMcpClientRegistryEntry(clientId);
     if (registryEntry?.logoKey)
-        return LOGO_URLS[registryEntry.logoKey];
+        return getProductLogoUrl(registryEntry.logoKey);
     if (!['chat_app', 'ide', 'cli', 'coding_tool'].includes(String(profile.surfaceType || '')))
         return '';
     const identity = [profile.username, profile.name]
@@ -53,32 +21,32 @@ export function getAiProfileDefaultLogoUrl(profile) {
     if (identity.includes('openclaw') || identity.includes('hermes agent'))
         return '';
     if (identity.includes('chatgpt'))
-        return chatgptLogo;
+        return getProductLogoUrl('chatgpt');
     if (identity.includes('claude code'))
-        return claudeCodeLogo;
+        return getProductLogoUrl('claude-code');
     if (identity.includes('claude desktop'))
-        return claudeChatLogo;
+        return getProductLogoUrl('claude-chat');
     if (identity.includes('cline'))
-        return clineLogo;
+        return getProductLogoUrl('cline');
     if (identity.includes('codex'))
-        return codexLogo;
+        return getProductLogoUrl('codex');
     if (identity.includes('cursor'))
-        return cursorLogo;
+        return getProductLogoUrl('cursor');
     if (identity.includes('cascade') || identity.includes('windsurf'))
-        return windsurfLogo;
+        return getProductLogoUrl('windsurf');
     if (identity.includes('antigravity'))
-        return antigravityLogo;
+        return getProductLogoUrl('antigravity');
     if (identity.includes('gemini'))
-        return geminiLogo;
+        return getProductLogoUrl('gemini-cli');
     if (identity.includes('grok'))
-        return grokLogo;
+        return getProductLogoUrl('grok');
     if (identity.includes('mistral') || identity.includes('le chat'))
-        return mistralLogo;
+        return getProductLogoUrl('mistral-chat');
     if (identity.includes('perplexity'))
-        return perplexityLogo;
+        return getProductLogoUrl('perplexity-chat');
     if (identity.includes('kiro'))
-        return kiroLogo;
+        return getProductLogoUrl('kiro');
     if (identity.includes('visual studio code') || identity.includes('vs code') || identity.includes('vscode'))
-        return vscodeLogo;
+        return getProductLogoUrl('vscode');
     return '';
 }

package/dist/utils/httpSetCookie.d.ts CHANGED Viewed

@@ -1,3 +1,4 @@
+export declare function stripSetCookieDomainAttribute(cookie: string): string;
 export declare function rewriteSetCookieForLocalHost(cookie: string): string;
 export declare function readSetCookieHeaders(headers: Headers): string[];
 export declare function findSetCookieHeader(headers: readonly string[], cookieName: string): string | null;

package/dist/utils/httpSetCookie.js CHANGED Viewed

@@ -1,4 +1,4 @@
-export function rewriteSetCookieForLocalHost(cookie) {
+export function stripSetCookieDomainAttribute(cookie) {
     const parts = String(cookie || '').split(';').map((part) => part.trim()).filter(Boolean);
     if (parts.length === 0)
         return cookie;
@@ -6,6 +6,9 @@ export function rewriteSetCookieForLocalHost(cookie) {
     const filteredAttrs = attrs.filter((attr) => !attr.toLowerCase().startsWith('domain='));
     return [nameValue, ...filteredAttrs].join('; ');
 }
+export function rewriteSetCookieForLocalHost(cookie) {
+    return stripSetCookieDomainAttribute(cookie);
+}
 export function readSetCookieHeaders(headers) {
     const values = headers.getSetCookie?.();
     if (Array.isArray(values) && values.length > 0)

package/dist/utils/localRuntimeUrl.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export declare function retargetRestartedLocalUrl(currentUrl: string, previousPort: number, restartedPort: number): string \| null;

package/dist/utils/localRuntimeUrl.js ADDED Viewed

@@ -0,0 +1,14 @@
+export function retargetRestartedLocalUrl(currentUrl, previousPort, restartedPort) {
+    if (previousPort === restartedPort)
+        return null;
+    try {
+        const target = new URL(currentUrl);
+        if (target.origin !== `http://localhost:${previousPort}`)
+            return null;
+        target.port = String(restartedPort);
+        return target.toString();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/productLogoRegistry.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { ProductLogoKey } from '../shared/productLogoKeys.js';
2	+ export declare function getProductLogoUrl(key: ProductLogoKey \| null \| undefined): string;

package/dist/utils/productLogoRegistry.js ADDED Viewed

@@ -0,0 +1,36 @@
+import antigravityLogo from '../assets/ai-profile-clients/antigravity.png';
+import chatgptLogo from '../assets/ai-profile-clients/chatgpt.svg';
+import claudeChatLogo from '../assets/ai-profile-clients/claude-chat.svg';
+import claudeCodeLogo from '../assets/ai-profile-clients/claude-code.svg';
+import clineLogo from '../assets/ai-profile-clients/cline.svg';
+import codexLogo from '../assets/ai-profile-clients/codex.svg';
+import cursorLogo from '../assets/ai-profile-clients/cursor.svg';
+import geminiLogo from '../assets/ai-profile-clients/gemini-cli-icon.png';
+import geminiChatLogo from '../assets/ai-profile-clients/gemini.svg';
+import grokLogo from '../assets/ai-profile-clients/grok.svg';
+import kiroLogo from '../assets/ai-profile-clients/kiro.svg';
+import mistralLogo from '../assets/ai-profile-clients/mistral.svg';
+import perplexityLogo from '../assets/ai-profile-clients/perplexity.svg';
+import vscodeLogo from '../assets/ai-profile-clients/vscode.svg';
+import windsurfLogo from '../assets/ai-profile-clients/windsurf.svg';
+const PRODUCT_LOGO_URLS = {
+    antigravity: antigravityLogo,
+    chatgpt: chatgptLogo,
+    'claude-chat': claudeChatLogo,
+    'claude-code': claudeCodeLogo,
+    cline: clineLogo,
+    codex: codexLogo,
+    cursor: cursorLogo,
+    'gemini-chat': geminiChatLogo,
+    'gemini-cli': geminiLogo,
+    grok: grokLogo,
+    'grok-chat': grokLogo,
+    kiro: kiroLogo,
+    'mistral-chat': mistralLogo,
+    'perplexity-chat': perplexityLogo,
+    vscode: vscodeLogo,
+    windsurf: windsurfLogo,
+};
+export function getProductLogoUrl(key) {
+    return key ? PRODUCT_LOGO_URLS[key] : '';
+}

package/dist/utils/syncStatusPresentation.d.ts CHANGED Viewed

@@ -65,6 +65,10 @@ export interface WorkspaceSyncDiagnosticsPresentation {
     } | null;
     coordinatorRecoveryObligations?: number;
 }
+export declare function resolveEffectiveWorkspaceSyncDiagnostics(browserDiagnostics: WorkspaceSyncDiagnosticsPresentation, coordinator: {
+    recoveryObligations: number;
+    outbox: WorkspaceSyncDiagnosticsPresentation['durableOutbox'];
+} | null): WorkspaceSyncDiagnosticsPresentation;
 interface BuildSyncEventRowsInput {
     syncRecentEvents: SyncEventRecord[];
     syncRecentEventsError: string | null;

package/dist/utils/syncStatusPresentation.js CHANGED Viewed

@@ -22,6 +22,15 @@ function getCollapsibleEventSignature(event) {
         stableStringifySyncEventDetails(event.details),
     ].join('|');
 }
+export function resolveEffectiveWorkspaceSyncDiagnostics(browserDiagnostics, coordinator) {
+    if (!coordinator)
+        return browserDiagnostics;
+    return {
+        ...browserDiagnostics,
+        durableOutbox: coordinator.outbox,
+        coordinatorRecoveryObligations: coordinator.recoveryObligations,
+    };
+}
 function formatDiagnosticsTimestamp(value) {
     if (!value)
         return 'Never';
@@ -48,6 +57,14 @@ export function resolveSyncStatusMeta(status) {
                 border: 'rgba(96, 165, 250, 0.35)',
                 background: 'rgba(59, 130, 246, 0.12)',
             };
+        case 'checking':
+            return {
+                label: 'Checking',
+                icon: 'cloud',
+                color: '#94a3b8',
+                border: 'rgba(148, 163, 184, 0.35)',
+                background: 'rgba(148, 163, 184, 0.12)',
+            };
         case 'attention':
             return {
                 label: 'Needs Attention',

package/dist/utils/taskActivity.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import type { EntityActivityItem, EntityEvent, TaskActivityItem, TaskEvent, TaskItem } from '../types';
+import type { EntityActivityItem, EntityEvent, TaskActivityItem, TaskActivitySummaryItem, TaskEvent, TaskItem } from '../types';
 export type TaskEventValueFormatter = (field: string, value: unknown) => string | undefined;
 type AttachmentChange = {
     from?: unknown;
@@ -11,6 +11,7 @@ type AttachmentChange = {
 };
 export declare function summarizeTaskChange(field: string, change: AttachmentChange | undefined, formatter?: TaskEventValueFormatter): string;
 export declare function summarizeTaskEvent(event: TaskEvent, formatter?: TaskEventValueFormatter): string;
+export declare function summarizeTaskEvent(event: Pick<TaskEvent, 'action' | 'details'>, formatter?: TaskEventValueFormatter): string;
 export declare function summarizeEntityEvent(event: EntityEvent, formatter?: TaskEventValueFormatter): string;
 export declare function getTaskEventPrimaryChangeField(event: TaskEvent): string | null;
 export declare function getEntityEventPrimaryChangeField(event: EntityEvent): string | null;
@@ -20,5 +21,5 @@ export declare function getEntityActivityItems(task: {
 }): EntityActivityItem[];
 export declare function getTaskActivityItems(task: Pick<TaskItem, 'activity' | 'comments'>): TaskActivityItem[];
 export declare function getLatestTaskActivity(task: Pick<TaskItem, 'activity' | 'comments'>): TaskActivityItem | null;
-export declare function summarizeTaskActivity(item: TaskActivityItem | null, formatter?: TaskEventValueFormatter): string;
+export declare function summarizeTaskActivity(item: TaskActivityItem | TaskActivitySummaryItem | null, formatter?: TaskEventValueFormatter): string;
 export {};

package/dist/utils/taskActivity.js CHANGED Viewed

@@ -5,8 +5,6 @@ function getActivityFieldLabel(field) {
         return 'Title';
     if (field === 'description')
         return 'Description';
-    if (field === 'assignee')
-        return 'Assigned to';
     if (field === 'ownerId')
         return 'Owner';
     if (field === 'status')
@@ -21,6 +19,14 @@ function getActivityFieldLabel(field) {
         return 'Initiative';
     return field;
 }
+function isUnassignedActivityValue(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return !normalized
+        || normalized === 'none'
+        || normalized === 'null'
+        || normalized === 'unassigned'
+        || normalized === 'user';
+}
 function formatStatusValue(value) {
     if (value === 'task')
         return 'Task';
@@ -277,6 +283,17 @@ export function summarizeTaskChange(field, change, formatter) {
     if (field === 'attachments') {
         return summarizeAttachmentChange(change);
     }
+    if (field === 'assignee') {
+        const previousAssignee = formatValue(change?.from, field, formatter);
+        const nextAssignee = formatValue(change?.to, field, formatter);
+        if (isUnassignedActivityValue(change?.from) && !isUnassignedActivityValue(change?.to)) {
+            return `Assigned to ${nextAssignee}`;
+        }
+        if (!isUnassignedActivityValue(change?.from) && isUnassignedActivityValue(change?.to)) {
+            return `Unassigned from ${previousAssignee}`;
+        }
+        return `Reassigned: ${previousAssignee} → ${nextAssignee}`;
+    }
     const label = getActivityFieldLabel(field);
     if (field === 'title') {
         return `${label}: updated`;

package/dist/utils/taskEditorReconciliation.d.ts ADDED Viewed

@@ -0,0 +1,40 @@
+import type { AttachmentItem, ChecklistItem, TaskAssignee, TaskItem, TaskStatus } from '../types';
+export interface TaskEditorDraft {
+    title: string;
+    description: string;
+    category: string;
+    type: string;
+    priority: number | string;
+    complexity: number;
+    status: TaskStatus;
+    assignee: TaskAssignee;
+    scheduledDate: string;
+    dueDate: string;
+    workstreamId: string;
+    taxonomies: Record<string, string | number | string[] | number[]>;
+    checklistItems: ChecklistItem[];
+    attachments: Array<string | AttachmentItem>;
+}
+export type TaskEditorScalarField = Exclude<keyof TaskEditorDraft, 'taxonomies' | 'checklistItems' | 'attachments'>;
+export type TaskEditorConflict = {
+    field: TaskEditorScalarField;
+} | {
+    field: 'taxonomies';
+    key: string;
+} | {
+    field: 'checklistItems' | 'attachments';
+    key: string;
+};
+export interface TaskEditorReconciliation {
+    merged: TaskEditorDraft;
+    conflicts: TaskEditorConflict[];
+    remoteChangedFields: string[];
+}
+export declare function taskToEditorDraft(task: TaskItem): TaskEditorDraft;
+export declare function applyEditorDraftToTask(task: TaskItem, draft: TaskEditorDraft): TaskItem;
+export declare function reconcileTaskEditorDraft(base: TaskEditorDraft, local: TaskEditorDraft, remote: TaskEditorDraft): TaskEditorReconciliation;
+export declare function resolveTaskEditorConflicts(reconciliation: TaskEditorReconciliation, remote: TaskEditorDraft, resolution: 'latest' | 'local', current?: TaskEditorDraft): TaskEditorDraft;
+export declare function isTaskEditorConflictAligned(conflict: TaskEditorConflict, local: TaskEditorDraft, remote: TaskEditorDraft): boolean;
+export declare function taskEditorConflictKey(conflict: TaskEditorConflict): string;
+export declare function preserveUnresolvedTaskEditorConflicts(existing: TaskEditorConflict[], next: TaskEditorConflict[], local: TaskEditorDraft, remote: TaskEditorDraft): TaskEditorConflict[];
+export declare function formatTaskEditorConflictFields(conflicts: TaskEditorConflict[]): string[];

package/dist/utils/taskEditorReconciliation.js ADDED Viewed

@@ -0,0 +1,217 @@
+import { canonicalWorkspaceSyncJson } from '../sync/v3/canonicalWorkspaceSyncJson.js';
+const SCALAR_FIELDS = [
+    'title',
+    'description',
+    'category',
+    'type',
+    'priority',
+    'complexity',
+    'status',
+    'assignee',
+    'scheduledDate',
+    'dueDate',
+    'workstreamId',
+];
+export function taskToEditorDraft(task) {
+    return {
+        title: task.title || '',
+        description: task.description || '',
+        category: task.category || '',
+        type: task.type || '',
+        priority: task.priority,
+        complexity: Number(task.complexity) || 3,
+        status: task.status || 'task',
+        assignee: task.assignee || 'unassigned',
+        scheduledDate: task.scheduledDate || '',
+        dueDate: task.dueDate || '',
+        workstreamId: task.workstreamId || '',
+        taxonomies: { ...(task.taxonomies || {}) },
+        checklistItems: [...(task.checklistItems || [])],
+        attachments: [...(task.attachments || [])],
+    };
+}
+export function applyEditorDraftToTask(task, draft) {
+    return {
+        ...task,
+        title: draft.title,
+        description: draft.description || null,
+        category: draft.category,
+        type: draft.type,
+        priority: draft.priority,
+        complexity: draft.complexity,
+        status: draft.status,
+        assignee: draft.assignee,
+        scheduledDate: draft.scheduledDate || null,
+        dueDate: draft.dueDate || null,
+        workstreamId: draft.workstreamId || null,
+        taxonomies: draft.taxonomies,
+        checklistItems: draft.checklistItems,
+        attachments: draft.attachments,
+    };
+}
+function equal(left, right) {
+    return canonicalWorkspaceSyncJson(left ?? null) === canonicalWorkspaceSyncJson(right ?? null);
+}
+function mergeValue(base, local, remote) {
+    const localChanged = !equal(local, base);
+    const remoteChanged = !equal(remote, base);
+    if (!localChanged)
+        return { value: remote, conflict: false, remoteChanged };
+    if (!remoteChanged || equal(local, remote))
+        return { value: local, conflict: false, remoteChanged };
+    return { value: local, conflict: true, remoteChanged };
+}
+function attachmentKey(attachment) {
+    if (typeof attachment === 'string')
+        return `path:${attachment}`;
+    if (attachment.assetId)
+        return `asset:${attachment.assetId}`;
+    if (attachment.referenceLabel)
+        return `reference:${attachment.referenceLabel}`;
+    if (attachment.referenceNumber != null)
+        return `number:${attachment.referenceNumber}`;
+    return `path:${attachment.path || attachment.fsPath || canonicalWorkspaceSyncJson(attachment)}`;
+}
+function mergeKeyedCollection(baseItems, localItems, remoteItems, getKey) {
+    const base = new Map(baseItems.map((item) => [getKey(item), item]));
+    const local = new Map(localItems.map((item) => [getKey(item), item]));
+    const remote = new Map(remoteItems.map((item) => [getKey(item), item]));
+    const keys = new Set([...base.keys(), ...remote.keys(), ...local.keys()]);
+    const merged = new Map();
+    const conflictKeys = [];
+    for (const key of keys) {
+        const baseItem = base.get(key);
+        const localItem = local.get(key);
+        const remoteItem = remote.get(key);
+        const result = mergeValue(baseItem, localItem, remoteItem);
+        if (result.value !== undefined)
+            merged.set(key, result.value);
+        if (result.conflict)
+            conflictKeys.push(key);
+    }
+    const orderedKeys = [
+        ...remoteItems.map(getKey),
+        ...localItems.map(getKey).filter((key) => !remote.has(key)),
+    ].filter((key, index, all) => all.indexOf(key) === index && merged.has(key));
+    return {
+        items: orderedKeys.map((key) => merged.get(key)),
+        conflictKeys,
+        remoteChanged: !equal(baseItems, remoteItems),
+    };
+}
+export function reconcileTaskEditorDraft(base, local, remote) {
+    const merged = { ...remote };
+    const conflicts = [];
+    const remoteChangedFields = new Set();
+    for (const field of SCALAR_FIELDS) {
+        const result = mergeValue(base[field], local[field], remote[field]);
+        merged[field] = result.value;
+        if (result.conflict)
+            conflicts.push({ field });
+        if (result.remoteChanged)
+            remoteChangedFields.add(field);
+    }
+    const taxonomyKeys = new Set([
+        ...Object.keys(base.taxonomies),
+        ...Object.keys(local.taxonomies),
+        ...Object.keys(remote.taxonomies),
+    ]);
+    const mergedTaxonomies = {};
+    for (const key of taxonomyKeys) {
+        const result = mergeValue(base.taxonomies[key], local.taxonomies[key], remote.taxonomies[key]);
+        if (result.value !== undefined)
+            mergedTaxonomies[key] = result.value;
+        if (result.conflict)
+            conflicts.push({ field: 'taxonomies', key });
+        if (result.remoteChanged)
+            remoteChangedFields.add(`taxonomies.${key}`);
+    }
+    merged.taxonomies = mergedTaxonomies;
+    const checklist = mergeKeyedCollection(base.checklistItems, local.checklistItems, remote.checklistItems, (item) => item.id);
+    merged.checklistItems = checklist.items;
+    checklist.conflictKeys.forEach((key) => conflicts.push({ field: 'checklistItems', key }));
+    if (checklist.remoteChanged)
+        remoteChangedFields.add('checklistItems');
+    const attachments = mergeKeyedCollection(base.attachments, local.attachments, remote.attachments, attachmentKey);
+    merged.attachments = attachments.items;
+    attachments.conflictKeys.forEach((key) => conflicts.push({ field: 'attachments', key }));
+    if (attachments.remoteChanged)
+        remoteChangedFields.add('attachments');
+    return { merged, conflicts, remoteChangedFields: [...remoteChangedFields] };
+}
+export function resolveTaskEditorConflicts(reconciliation, remote, resolution, current = reconciliation.merged) {
+    if (resolution === 'local')
+        return current;
+    const resolved = {
+        ...current,
+        taxonomies: { ...current.taxonomies },
+        checklistItems: [...current.checklistItems],
+        attachments: [...current.attachments],
+    };
+    for (const conflict of reconciliation.conflicts) {
+        if (conflict.field === 'taxonomies') {
+            const value = remote.taxonomies[conflict.key];
+            if (value === undefined)
+                delete resolved.taxonomies[conflict.key];
+            else
+                resolved.taxonomies[conflict.key] = value;
+            continue;
+        }
+        if (conflict.field === 'checklistItems' || conflict.field === 'attachments') {
+            const getKey = conflict.field === 'checklistItems'
+                ? (item) => item.id
+                : (item) => attachmentKey(item);
+            const current = resolved[conflict.field];
+            const latest = remote[conflict.field];
+            const latestItem = latest.find((item) => getKey(item) === conflict.key);
+            const withoutConflict = current.filter((item) => getKey(item) !== conflict.key);
+            resolved[conflict.field] = latestItem
+                ? [...withoutConflict, latestItem]
+                : withoutConflict;
+            continue;
+        }
+        resolved[conflict.field] = remote[conflict.field];
+    }
+    return resolved;
+}
+export function isTaskEditorConflictAligned(conflict, local, remote) {
+    if (conflict.field === 'taxonomies') {
+        return equal(local.taxonomies[conflict.key], remote.taxonomies[conflict.key]);
+    }
+    if (conflict.field === 'checklistItems') {
+        return equal(local.checklistItems.find((item) => item.id === conflict.key), remote.checklistItems.find((item) => item.id === conflict.key));
+    }
+    if (conflict.field === 'attachments') {
+        return equal(local.attachments.find((item) => attachmentKey(item) === conflict.key), remote.attachments.find((item) => attachmentKey(item) === conflict.key));
+    }
+    return equal(local[conflict.field], remote[conflict.field]);
+}
+export function taskEditorConflictKey(conflict) {
+    return 'key' in conflict ? `${conflict.field}:${conflict.key}` : conflict.field;
+}
+export function preserveUnresolvedTaskEditorConflicts(existing, next, local, remote) {
+    const conflictsByKey = new Map([
+        ...existing.filter((conflict) => !isTaskEditorConflictAligned(conflict, local, remote)),
+        ...next,
+    ].map((conflict) => [taskEditorConflictKey(conflict), conflict]));
+    return [...conflictsByKey.values()];
+}
+export function formatTaskEditorConflictFields(conflicts) {
+    const labels = {
+        title: 'title',
+        description: 'description',
+        category: 'category',
+        type: 'type',
+        priority: 'priority',
+        complexity: 'complexity',
+        status: 'status',
+        assignee: 'assignee',
+        scheduledDate: 'scheduled date',
+        dueDate: 'due date',
+        workstreamId: 'workstream',
+        taxonomies: 'taxonomy',
+        checklistItems: 'checklist',
+        attachments: 'attachments',
+    };
+    return [...new Set(conflicts.map((conflict) => labels[conflict.field] || String(conflict.field)))];
+}

package/dist/utils/taskEvents.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import type { TaskItem } from '../types.js';
+import type { WorkflowAssignmentDetails } from '../components/features/workflowManager/types.js';
 import type { TaskCollection } from './taskInvalidation.js';
 export declare const TASKFORCE_TASKS_MUTATED_EVENT = "taskforce:tasks-mutated";
 export interface TaskforceTasksMutatedDetail {
@@ -6,6 +7,7 @@ export interface TaskforceTasksMutatedDetail {
     taskId?: string | null;
     reason?: 'agent-comment' | 'agent-checklist' | 'workflow-step';
     authoritativeTask?: TaskItem | null;
+    authoritativeWorkflowAssignment?: WorkflowAssignmentDetails | null;
     affectedCollections?: TaskCollection[];
 }
 export declare function dispatchTaskforceTasksMutated(detail: TaskforceTasksMutatedDetail): void;

package/dist/utils/taskNormalization.d.ts CHANGED Viewed

@@ -13,6 +13,7 @@ export declare function normalizePriorityDefinitions(priorities: PriorityDefinit
     changed: boolean;
 };
 export declare function normalizeTaskFromApi(task: any): TaskItem;
+export declare function toTaskCollectionSummary(task: TaskItem): TaskItem;
 export declare function getTaskContentRevision(task: TaskItem): string;
 export declare function reconcileTaskCollection(previous: TaskItem[], incoming: TaskItem[]): TaskItem[];
 export declare function mergeNormalizedTaskIntoCollections(task: unknown, tasks: TaskItem[], archivedTasks: TaskItem[]): {

package/dist/utils/taskNormalization.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { cloneDefaultPriorityDefinitions } from '../shared/taxonomyDefaults.js';
 import { formatLocalTaskReference, formatTaskReference } from './taskReferences.js';
+import { getLatestTaskActivity } from './taskActivity.js';
 export const DEFAULT_PRIORITY_DEFINITIONS = cloneDefaultPriorityDefinitions();
 const PRIORITY_VALUE_BY_LABEL = {
     low: 1,
@@ -96,6 +97,44 @@ export function normalizeTaskFromApi(task) {
         status: normalizeTaskStatus(task.status)
     };
 }
+export function toTaskCollectionSummary(task) {
+    const { description: _description, comments, activity: _activity, taskEvents: _taskEvents, attachments, checklistItems, createdByActor: _createdByActor, assigneeActor: _assigneeActor, ...summary } = task;
+    const latestRevision = (values) => values.reduce((latest, value) => String(value || '') > latest ? String(value || '') : latest, '');
+    const commentCount = task.commentCount ?? comments?.length ?? 0;
+    const checklistCount = task.checklistCount ?? checklistItems?.length ?? 0;
+    const completedChecklistCount = task.completedChecklistCount
+        ?? checklistItems?.filter((item) => item.isCompleted).length
+        ?? 0;
+    const attachmentCount = task.attachmentCount ?? attachments?.length ?? 0;
+    const relationshipCount = task.relationshipCount ?? 0;
+    const latestActivity = task.latestActivity ?? getLatestTaskActivity(task);
+    return {
+        ...summary,
+        cardCoverAttachment: task.cardCoverAttachment ?? (task.cardCoverAssetId
+            ? attachments?.find((attachment) => (typeof attachment !== 'string' && attachment.assetId === task.cardCoverAssetId)) || null
+            : null),
+        isSummary: true,
+        commentCount,
+        checklistCount,
+        completedChecklistCount,
+        attachmentCount,
+        relationshipCount,
+        latestActivity,
+        detailRevision: task.detailRevision || JSON.stringify([
+            String(task.updatedAt || task.createdAt || ''),
+            commentCount,
+            latestRevision(comments?.map((comment) => comment.timestamp) || []),
+            checklistCount,
+            completedChecklistCount,
+            latestRevision(checklistItems?.map((item) => item.updatedAt || item.createdAt) || []),
+            attachmentCount,
+            latestRevision(attachments?.map((attachment) => typeof attachment === 'string' ? '' : attachment.timestamp) || []),
+            relationshipCount,
+            latestActivity?.timestamp || '',
+            latestActivity?.id || '',
+        ]),
+    };
+}
 export function getTaskContentRevision(task) {
     // Use the complete normalized snapshot: some task changes can arrive without a
     // distinct updatedAt value, so a timestamp-only key could retain stale UI data.

package/dist/utils/taskSearch.js CHANGED Viewed

@@ -1,5 +1,5 @@
-import { STATUS_OPTIONS } from './constants';
-import { getTaskReferenceLabel } from './taskReferences';
+import { STATUS_OPTIONS } from './constants.js';
+import { getTaskReferenceLabel } from './taskReferences.js';
 const DASH_LIKE_PATTERN = /[\u2010-\u2015\u2212]/g;
 export function normalizeSearchText(value) {
     return String(value ?? '')