@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/utils/documentNames.js

@@ -0,0 +1,91 @@
+function basename(value) {
+    const normalized = String(value || '').trim().replace(/\\/g, '/');
+    if (!normalized)
+        return '';
+    const segments = normalized.split('/').filter(Boolean);
+    return segments[segments.length - 1] || '';
+}
+function splitExtension(filename) {
+    const trimmed = String(filename || '').trim();
+    const dotIndex = trimmed.lastIndexOf('.');
+    if (dotIndex <= 0)
+        return { stem: trimmed, ext: '' };
+    return {
+        stem: trimmed.slice(0, dotIndex),
+        ext: trimmed.slice(dotIndex)
+    };
+}
+function stripAssetPrefix(stem, assetId) {
+    const trimmedStem = String(stem || '').trim();
+    const trimmedAssetId = String(assetId || '').trim();
+    if (!trimmedStem)
+        return '';
+    if (trimmedAssetId && trimmedStem.startsWith(`${trimmedAssetId}-`)) {
+        return trimmedStem.slice(trimmedAssetId.length + 1);
+    }
+    return trimmedStem.replace(/^asset-[a-z0-9-]+-/i, '');
+}
+function humanizeStem(stem) {
+    return String(stem || '')
+        .replace(/-\d{13,}$/g, '')
+        .replace(/[_-]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function deriveNameFromFilename(filename, assetId) {
+    const { stem, ext } = splitExtension(basename(filename));
+    const strippedStem = stripAssetPrefix(stem, assetId);
+    const humanizedStem = humanizeStem(strippedStem || stem);
+    if (!humanizedStem)
+        return basename(filename) || 'Untitled document';
+    return `${humanizedStem}${ext}`;
+}
+export function isGeneratedDocumentName(value, assetId) {
+    const trimmed = String(value || '').trim();
+    if (!trimmed)
+        return true;
+    const normalized = basename(trimmed);
+    const { stem } = splitExtension(normalized);
+    const trimmedAssetId = String(assetId || '').trim();
+    if (trimmedAssetId && stem.toLowerCase() === trimmedAssetId.toLowerCase()) {
+        return true;
+    }
+    const strippedStem = stripAssetPrefix(stem, assetId);
+    if (!strippedStem)
+        return true;
+    return strippedStem !== stem;
+}
+export function getCanonicalDocumentName(input) {
+    const logicalName = String(input.logicalName || '').trim();
+    if (logicalName && !isGeneratedDocumentName(logicalName, input.assetId)) {
+        return logicalName;
+    }
+    const displayName = String(input.displayName || '').trim();
+    if (displayName && !isGeneratedDocumentName(displayName, input.assetId)) {
+        return displayName;
+    }
+    const title = String(input.title || '').trim();
+    if (title && !isGeneratedDocumentName(title, input.assetId)) {
+        return title;
+    }
+    const originalFilename = String(input.originalFilename || '').trim();
+    if (originalFilename)
+        return deriveNameFromFilename(originalFilename, input.assetId);
+    const pathName = String(input.fsPath || '').trim();
+    if (pathName)
+        return deriveNameFromFilename(pathName, input.assetId);
+    return 'Untitled document';
+}
+export function getReadableDocumentName(doc) {
+    return getCanonicalDocumentName(doc);
+}
+export function getDocumentDownloadName(doc) {
+    const readableName = getReadableDocumentName(doc);
+    const filenameSource = String(doc.originalFilename || doc.fsPath || '').trim();
+    const sourceExt = splitExtension(basename(filenameSource)).ext;
+    if (!sourceExt)
+        return readableName;
+    return readableName.toLowerCase().endsWith(sourceExt.toLowerCase())
+        ? readableName
+        : `${readableName}${sourceExt}`;
+}

package/dist/utils/documentReferences.d.ts

@@ -0,0 +1,9 @@
+export declare const DOCUMENT_REFERENCE_PREFIX = "D-";
+export declare function formatDocumentReference(value: number | {
+    referenceNumber?: number | null;
+} | null | undefined): string;
+export declare function parseDocumentReference(value: string | null | undefined): number | null;
+export declare function getDocumentReferenceLabel(entity: {
+    referenceNumber?: number | null;
+    referenceLabel?: string | null;
+} | null | undefined): string;

package/dist/utils/documentReferences.js

@@ -0,0 +1,11 @@
+import { formatEntityReference, getEntityReferenceLabel, parseEntityReference } from './entityReferences.js';
+export const DOCUMENT_REFERENCE_PREFIX = 'D-';
+export function formatDocumentReference(value) {
+    return formatEntityReference(DOCUMENT_REFERENCE_PREFIX, value);
+}
+export function parseDocumentReference(value) {
+    return parseEntityReference(DOCUMENT_REFERENCE_PREFIX, value);
+}
+export function getDocumentReferenceLabel(entity) {
+    return getEntityReferenceLabel(DOCUMENT_REFERENCE_PREFIX, entity);
+}

package/dist/utils/entityReferences.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeEntityReferenceNumber(value: unknown): number | null;
+export declare function formatEntityReference(prefix: string, value: number | {
+    referenceNumber?: number | null;
+} | null | undefined): string;
+export declare function parseEntityReference(prefix: string, value: string | null | undefined): number | null;
+export declare function getEntityReferenceLabel(prefix: string, entity: {
+    referenceNumber?: number | null;
+    referenceLabel?: string | null;
+} | null | undefined): string;

package/dist/utils/entityReferences.js

@@ -0,0 +1,32 @@
+export function normalizeEntityReferenceNumber(value) {
+    const numeric = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(numeric))
+        return null;
+    const normalized = Math.floor(numeric);
+    return normalized > 0 ? normalized : null;
+}
+export function formatEntityReference(prefix, value) {
+    const referenceNumber = typeof value === 'object' && value !== null
+        ? normalizeEntityReferenceNumber(value.referenceNumber)
+        : normalizeEntityReferenceNumber(value);
+    return referenceNumber ? `${prefix}${referenceNumber}` : '';
+}
+export function parseEntityReference(prefix, value) {
+    const normalizedPrefix = String(prefix || '').trim();
+    const normalizedValue = String(value || '').trim();
+    if (!normalizedPrefix || !normalizedValue)
+        return null;
+    const escapedPrefix = normalizedPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = normalizedValue.match(new RegExp(`^${escapedPrefix}(\\d+)$`, 'i'));
+    if (!match)
+        return null;
+    return normalizeEntityReferenceNumber(match[1]);
+}
+export function getEntityReferenceLabel(prefix, entity) {
+    if (!entity)
+        return '';
+    if (typeof entity.referenceLabel === 'string' && entity.referenceLabel.trim().length > 0) {
+        return entity.referenceLabel.trim();
+    }
+    return formatEntityReference(prefix, entity.referenceNumber);
+}

package/dist/utils/imageReferences.d.ts

@@ -0,0 +1,9 @@
+export declare const IMAGE_REFERENCE_PREFIX = "I-";
+export declare function formatImageReference(value: number | {
+    referenceNumber?: number | null;
+} | null | undefined): string;
+export declare function parseImageReference(value: string | null | undefined): number | null;
+export declare function getImageReferenceLabel(entity: {
+    referenceNumber?: number | null;
+    referenceLabel?: string | null;
+} | null | undefined): string;

package/dist/utils/imageReferences.js

@@ -0,0 +1,11 @@
+import { formatEntityReference, getEntityReferenceLabel, parseEntityReference } from './entityReferences.js';
+export const IMAGE_REFERENCE_PREFIX = 'I-';
+export function formatImageReference(value) {
+    return formatEntityReference(IMAGE_REFERENCE_PREFIX, value);
+}
+export function parseImageReference(value) {
+    return parseEntityReference(IMAGE_REFERENCE_PREFIX, value);
+}
+export function getImageReferenceLabel(entity) {
+    return getEntityReferenceLabel(IMAGE_REFERENCE_PREFIX, entity);
+}

package/dist/utils/planParser.d.ts

@@ -3,8 +3,8 @@
  * Parses a markdown implementation plan into a structured task tree.
  * Pure function — no I/O, no side effects.
  */
-export type ParsedTaskType = 'feature' | 'bug' | 'chore' | 'refactor' | 'documentation';
-export type ParsedTaskPriority = 1 | 2 | 3 | 4;
+export type ParsedTaskType = 'task' | 'deliverable' | 'issue' | 'idea' | 'review';
+export type ParsedTaskPriority = 1 | 2 | 3;
 export interface ParsedTask {
     /** Stable key for idempotent generation — derived from title + depth */
     idempotencyKey: string;

package/dist/utils/planParser.js

@@ -6,22 +6,22 @@
 // ─── Inference helpers ──────────────────────────────────────────────────────
 function inferType(title) {
     const l = title.toLowerCase();
-    if (/\b(bug|fix|fixes|fixed|broken|broken|regression|hotfix)\b/.test(l))
-        return 'bug';
-    if (/\b(refactor|refactoring|rewrite|cleanup|clean.?up|reorgani[sz]e)\b/.test(l))
-        return 'refactor';
-    if (/\b(doc|docs|documentation|readme|changelog|comment|comments)\b/.test(l))
-        return 'documentation';
-    if (/\b(chore|setup|set.?up|config|configuration|infra|infrastructure|ci|cd|deploy|migration|upgrade)\b/.test(l))
-        return 'chore';
-    return 'feature';
+    if (/\b(bug|fix|fixes|fixed|broken|regression|hotfix|incident|blocker)\b/.test(l))
+        return 'issue';
+    if (/\b(review|approve|approval|qa|test|testing|audit|verify|validation)\b/.test(l))
+        return 'review';
+    if (/\b(idea|brainstorm|prototype|spike|explor|experiment)\b/.test(l))
+        return 'idea';
+    if (/\b(doc|docs|documentation|readme|changelog|comment|comments|spec|design|copy|wireframe|mockup|asset|content)\b/.test(l))
+        return 'deliverable';
+    return 'task';
 }
 function inferPriority(title) {
     const l = title.toLowerCase();
-    if (/\b(critical|blocker|p0|urgent)\b/.test(l))
-        return 4;
     if (/\b(high|important|p1)\b/.test(l))
         return 3;
+    if (/\b(critical|blocker|p0|urgent)\b/.test(l))
+        return 3;
     if (/\b(low|minor|nice.?to.?have|p3)\b/.test(l))
         return 1;
     return 2;

package/dist/utils/planParser.test.d.ts

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

package/dist/{__tests__ → utils}/planParser.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parsePlan, flattenSelected } from '../utils/planParser';
+import { parsePlan, flattenSelected } from './planParser';
 // ─── parsePlan ───────────────────────────────────────────────────────────────
 describe('parsePlan', () => {
     it('returns empty array for empty content', () => {
@@ -72,27 +72,27 @@ describe('parsePlan — type inference', () => {
     function typeOf(title) {
         return parsePlan(`## ${title}`)[0].type;
     }
-    it('infers "bug" for fix/bug keywords', () => {
-        expect(typeOf('Fix login bug')).toBe('bug');
-        expect(typeOf('Bug: broken redirect')).toBe('bug');
-        expect(typeOf('Hotfix for session issue')).toBe('bug');
+    it('infers "issue" for fix/bug keywords', () => {
+        expect(typeOf('Fix login bug')).toBe('issue');
+        expect(typeOf('Bug: broken redirect')).toBe('issue');
+        expect(typeOf('Hotfix for session issue')).toBe('issue');
     });
-    it('infers "refactor" for refactor/cleanup keywords', () => {
-        expect(typeOf('Refactor auth module')).toBe('refactor');
-        expect(typeOf('Clean up legacy routes')).toBe('refactor');
+    it('defaults refactor/cleanup work to "task"', () => {
+        expect(typeOf('Refactor auth module')).toBe('task');
+        expect(typeOf('Clean up legacy routes')).toBe('task');
     });
-    it('infers "documentation" for docs keywords', () => {
-        expect(typeOf('Update README')).toBe('documentation');
-        expect(typeOf('Write docs for API')).toBe('documentation');
+    it('infers "deliverable" for docs keywords', () => {
+        expect(typeOf('Update README')).toBe('deliverable');
+        expect(typeOf('Write docs for API')).toBe('deliverable');
     });
-    it('infers "chore" for setup/config/deploy keywords', () => {
-        expect(typeOf('Setup CI pipeline')).toBe('chore');
-        expect(typeOf('Config environment')).toBe('chore');
-        expect(typeOf('Deploy infrastructure')).toBe('chore');
+    it('defaults to "task" for setup/config/deploy keywords', () => {
+        expect(typeOf('Setup CI pipeline')).toBe('task');
+        expect(typeOf('Config environment')).toBe('task');
+        expect(typeOf('Deploy infrastructure')).toBe('task');
     });
-    it('defaults to "feature" for unrecognised titles', () => {
-        expect(typeOf('Add user dashboard')).toBe('feature');
-        expect(typeOf('Phase 1 — Core Module')).toBe('feature');
+    it('defaults to "task" for unrecognised titles', () => {
+        expect(typeOf('Add user dashboard')).toBe('task');
+        expect(typeOf('Phase 1 — Core Module')).toBe('task');
     });
 });
 // ─── Priority inference ──────────────────────────────────────────────────────
@@ -100,10 +100,10 @@ describe('parsePlan — priority inference', () => {
     function priorityOf(title) {
         return parsePlan(`## ${title}`)[0].priority;
     }
-    it('infers priority 4 (Critical) for "critical" / "blocker" / "p0"', () => {
-        expect(priorityOf('Critical: auth bypass')).toBe(4);
-        expect(priorityOf('Blocker — build fails')).toBe(4);
-        expect(priorityOf('P0 fix needed')).toBe(4);
+    it('maps "critical" / "blocker" / "p0" to the highest 3-level priority', () => {
+        expect(priorityOf('Critical: auth bypass')).toBe(3);
+        expect(priorityOf('Blocker — build fails')).toBe(3);
+        expect(priorityOf('P0 fix needed')).toBe(3);
     });
     it('infers priority 3 (High) for "high" / "important"', () => {
         expect(priorityOf('High priority task')).toBe(3);

package/dist/utils/planningReferences.d.ts

@@ -0,0 +1,17 @@
+type ReferenceLike = {
+    referenceNumber?: number | null;
+    referenceLabel?: string | null;
+};
+export declare const WORKSTREAM_REFERENCE_PREFIX = "WS-";
+export declare const INITIATIVE_REFERENCE_PREFIX = "IN-";
+export declare function formatWorkstreamReference(value: number | ReferenceLike | null | undefined): string;
+export declare function parseWorkstreamReference(value: string | null | undefined): number | null;
+export declare function getWorkstreamReferenceLabel(workstream: ReferenceLike | null | undefined): string;
+export declare function formatInitiativeReference(value: number | ReferenceLike | null | undefined): string;
+export declare function parseInitiativeReference(value: string | null | undefined): number | null;
+export declare function getInitiativeReferenceLabel(initiative: ReferenceLike | null | undefined): string;
+type InitiativeReferenceLike = ReferenceLike & {
+    id: string;
+};
+export declare function resolveInitiativeReference<T extends InitiativeReferenceLike>(initiatives: T[], value: string | null | undefined): T | null;
+export {};

package/dist/utils/planningReferences.js

@@ -0,0 +1,30 @@
+import { formatEntityReference, getEntityReferenceLabel, parseEntityReference, } from './entityReferences.js';
+export const WORKSTREAM_REFERENCE_PREFIX = 'WS-';
+export const INITIATIVE_REFERENCE_PREFIX = 'IN-';
+export function formatWorkstreamReference(value) {
+    return formatEntityReference(WORKSTREAM_REFERENCE_PREFIX, value);
+}
+export function parseWorkstreamReference(value) {
+    return parseEntityReference(WORKSTREAM_REFERENCE_PREFIX, value);
+}
+export function getWorkstreamReferenceLabel(workstream) {
+    return getEntityReferenceLabel(WORKSTREAM_REFERENCE_PREFIX, workstream);
+}
+export function formatInitiativeReference(value) {
+    return formatEntityReference(INITIATIVE_REFERENCE_PREFIX, value);
+}
+export function parseInitiativeReference(value) {
+    return parseEntityReference(INITIATIVE_REFERENCE_PREFIX, value);
+}
+export function getInitiativeReferenceLabel(initiative) {
+    return getEntityReferenceLabel(INITIATIVE_REFERENCE_PREFIX, initiative);
+}
+export function resolveInitiativeReference(initiatives, value) {
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        return null;
+    const exactReferenceNumber = parseInitiativeReference(normalized);
+    return initiatives.find((initiative) => (initiative.id === normalized
+        || formatInitiativeReference(initiative) === normalized
+        || (exactReferenceNumber !== null && initiative.referenceNumber === exactReferenceNumber))) || null;
+}

package/dist/utils/planningReferences.test.d.ts

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

package/dist/utils/planningReferences.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { formatInitiativeReference, resolveInitiativeReference, } from './planningReferences';
+describe('planningReferences', () => {
+    const initiatives = [
+        { id: 'initiative-1', referenceNumber: 1, title: 'Alpha' },
+        { id: 'initiative-2', referenceNumber: 2, title: 'Beta' },
+    ];
+    it('resolves initiative references by id and formatted label', () => {
+        expect(resolveInitiativeReference(initiatives, 'initiative-1')?.id).toBe('initiative-1');
+        expect(resolveInitiativeReference(initiatives, formatInitiativeReference(initiatives[1]))?.id).toBe('initiative-2');
+    });
+    it('returns null for empty or invalid initiative references', () => {
+        expect(resolveInitiativeReference(initiatives, '')).toBeNull();
+        expect(resolveInitiativeReference(initiatives, 'IN-999')).toBeNull();
+        expect(resolveInitiativeReference(initiatives, 'not-a-reference')).toBeNull();
+    });
+});

package/dist/utils/taskActivity.d.ts

@@ -0,0 +1,9 @@
+import type { TaskActivityItem, TaskEvent, TaskItem } from '../types';
+export type TaskEventValueFormatter = (field: string, value: unknown) => string | undefined;
+export declare function summarizeTaskChange(field: string, change: {
+    from?: unknown;
+    to?: unknown;
+} | undefined, formatter?: TaskEventValueFormatter): string;
+export declare function summarizeTaskEvent(event: TaskEvent, formatter?: TaskEventValueFormatter): string;
+export declare function getLatestTaskActivity(task: Pick<TaskItem, 'activity' | 'comments'>): TaskActivityItem | null;
+export declare function summarizeTaskActivity(item: TaskActivityItem | null, formatter?: TaskEventValueFormatter): string;

package/dist/utils/taskActivity.js

@@ -0,0 +1,147 @@
+function formatValue(value, field, formatter) {
+    const formatted = formatter?.(field, value);
+    if (typeof formatted === 'string')
+        return formatted;
+    if (value === null || value === undefined || value === '')
+        return 'none';
+    if (Array.isArray(value)) {
+        const normalized = value.map((entry) => formatValue(entry, field, formatter)).filter(Boolean);
+        return normalized.length > 0 ? normalized.join(', ') : 'none';
+    }
+    if (typeof value === 'object')
+        return 'updated';
+    return String(value);
+}
+function normalizeChecklistItems(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry, index) => {
+        const item = (entry && typeof entry === 'object' ? entry : {});
+        const orderValue = Number(item.order);
+        return {
+            id: String(item.id || '').trim(),
+            title: String(item.title || '').trim(),
+            isCompleted: Boolean(item.isCompleted),
+            order: Number.isFinite(orderValue) ? orderValue : index,
+        };
+    });
+}
+function summarizeChecklistChange(change) {
+    const before = normalizeChecklistItems(change?.from);
+    const after = normalizeChecklistItems(change?.to);
+    const beforeById = new Map(before.map((item) => [item.id || item.title, item]));
+    const afterById = new Map(after.map((item) => [item.id || item.title, item]));
+    for (const [key, nextItem] of afterById.entries()) {
+        const prevItem = beforeById.get(key);
+        if (!prevItem) {
+            return nextItem.title ? `Checklist item added: ${nextItem.title}` : 'Checklist item added';
+        }
+        if (prevItem.isCompleted !== nextItem.isCompleted) {
+            if (nextItem.title) {
+                return nextItem.isCompleted
+                    ? `Checklist item completed: ${nextItem.title}`
+                    : `Checklist item reopened: ${nextItem.title}`;
+            }
+            return nextItem.isCompleted ? 'Checklist item completed' : 'Checklist item reopened';
+        }
+    }
+    for (const [key, prevItem] of beforeById.entries()) {
+        if (!afterById.has(key)) {
+            return prevItem.title ? `Checklist item removed: ${prevItem.title}` : 'Checklist item removed';
+        }
+    }
+    const sameMembership = before.length === after.length
+        && before.every((item) => afterById.has(item.id || item.title));
+    if (sameMembership) {
+        const orderChanged = before.some((item, index) => {
+            const nextItem = after[index];
+            return (item.id || item.title) !== (nextItem?.id || nextItem?.title);
+        });
+        if (orderChanged)
+            return 'Checklist reordered';
+    }
+    return 'Checklist updated';
+}
+export function summarizeTaskChange(field, change, formatter) {
+    if (field === 'checklistItems') {
+        return summarizeChecklistChange(change);
+    }
+    if (field === 'description') {
+        const hadBefore = formatValue(change?.from, field, formatter) !== 'none';
+        const hasAfter = formatValue(change?.to, field, formatter) !== 'none';
+        if (!hadBefore && hasAfter)
+            return 'Description added';
+        if (hadBefore && !hasAfter)
+            return 'Description cleared';
+        return 'Description updated';
+    }
+    return `${field}: ${formatValue(change?.from, field, formatter)} -> ${formatValue(change?.to, field, formatter)}`;
+}
+export function summarizeTaskEvent(event, formatter) {
+    const changes = event.details?.changes || {};
+    const fields = Object.keys(changes);
+    if (event.action === 'task-created')
+        return 'Task created';
+    if (event.action === 'task-comment-added')
+        return 'Comment added';
+    if (event.action === 'task-archived')
+        return 'Task marked done';
+    if (event.action === 'task-cancelled')
+        return 'Task cancelled';
+    if (event.action === 'task-unarchived')
+        return 'Task restored';
+    if (event.action === 'task-status-changed' && changes.status) {
+        return `Status: ${formatValue(changes.status.from, 'status', formatter)} -> ${formatValue(changes.status.to, 'status', formatter)}`;
+    }
+    if (event.action === 'task-schedule-changed') {
+        if (changes.scheduledDate) {
+            return `Scheduled: ${formatValue(changes.scheduledDate.from, 'scheduledDate', formatter)} -> ${formatValue(changes.scheduledDate.to, 'scheduledDate', formatter)}`;
+        }
+        if (changes.dueDate) {
+            return `Due: ${formatValue(changes.dueDate.from, 'dueDate', formatter)} -> ${formatValue(changes.dueDate.to, 'dueDate', formatter)}`;
+        }
+        return 'Schedule updated';
+    }
+    if (event.action === 'task-relationship-changed' && changes.workstreamId) {
+        return `Workstream: ${formatValue(changes.workstreamId.from, 'workstreamId', formatter)} -> ${formatValue(changes.workstreamId.to, 'workstreamId', formatter)}`;
+    }
+    if (event.action === 'task-attachments-changed')
+        return 'Attachments updated';
+    if (fields.length === 1) {
+        const field = fields[0];
+        const change = changes[field];
+        return summarizeTaskChange(field, change, formatter);
+    }
+    if (fields.length > 1)
+        return `${fields.length} fields updated`;
+    return 'Task updated';
+}
+export function getLatestTaskActivity(task) {
+    const items = Array.isArray(task.activity) && task.activity.length > 0
+        ? task.activity
+        : Array.isArray(task.comments)
+            ? task.comments.map((comment) => ({
+                id: `comment:${comment.id}`,
+                type: 'comment',
+                timestamp: comment.timestamp,
+                comment
+            }))
+            : [];
+    if (items.length === 0)
+        return null;
+    return [...items].sort((left, right) => {
+        const leftTs = Date.parse(String(left.timestamp || ''));
+        const rightTs = Date.parse(String(right.timestamp || ''));
+        if (Number.isFinite(leftTs) && Number.isFinite(rightTs) && leftTs !== rightTs) {
+            return rightTs - leftTs;
+        }
+        return String(right.id || '').localeCompare(String(left.id || ''));
+    })[0] || null;
+}
+export function summarizeTaskActivity(item, formatter) {
+    if (!item)
+        return '';
+    if (item.type === 'comment')
+        return item.comment.text;
+    return summarizeTaskEvent(item.event, formatter);
+}

package/dist/utils/taskActivity.test.d.ts

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

package/dist/utils/taskActivity.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { summarizeTaskChange } from './taskActivity';
+describe('summarizeTaskChange', () => {
+    it('summarizes checklist completion clearly', () => {
+        expect(summarizeTaskChange('checklistItems', {
+            from: [{ id: 'a', title: 'First item', isCompleted: false, order: 0 }],
+            to: [{ id: 'a', title: 'First item', isCompleted: true, order: 0 }],
+        })).toBe('Checklist item completed: First item');
+    });
+    it('summarizes checklist additions clearly', () => {
+        expect(summarizeTaskChange('checklistItems', {
+            from: [],
+            to: [{ id: 'a', title: 'First item', isCompleted: false, order: 0 }],
+        })).toBe('Checklist item added: First item');
+    });
+    it('summarizes checklist removals clearly', () => {
+        expect(summarizeTaskChange('checklistItems', {
+            from: [{ id: 'a', title: 'First item', isCompleted: false, order: 0 }],
+            to: [],
+        })).toBe('Checklist item removed: First item');
+    });
+    it('summarizes checklist reorder clearly', () => {
+        expect(summarizeTaskChange('checklistItems', {
+            from: [
+                { id: 'a', title: 'First item', isCompleted: false, order: 0 },
+                { id: 'b', title: 'Second item', isCompleted: false, order: 1 },
+            ],
+            to: [
+                { id: 'b', title: 'Second item', isCompleted: false, order: 0 },
+                { id: 'a', title: 'First item', isCompleted: false, order: 1 },
+            ],
+        })).toBe('Checklist reordered');
+    });
+});

package/dist/utils/taskDraftDefaults.d.ts

@@ -0,0 +1,21 @@
+import type { CategoryConfig, TaskAssignee, TaskStatus } from '../types';
+type ApproachOption = {
+    value: string;
+    label: string;
+};
+export interface DraftDefaultsForGrouping {
+    category?: string;
+    type?: string;
+    priority?: number;
+    complexity?: number;
+    approach?: string;
+    taxonomyApproach?: string;
+    assignee?: TaskAssignee;
+    status?: TaskStatus;
+    scheduledDate?: string;
+}
+export declare function resolveDraftDefaultsForGrouping(groupField: string, value: string | number, options: {
+    categories: CategoryConfig[];
+    approaches: ApproachOption[];
+}): DraftDefaultsForGrouping;
+export {};

package/dist/utils/taskDraftDefaults.js

@@ -0,0 +1,40 @@
+export function resolveDraftDefaultsForGrouping(groupField, value, options) {
+    const normalizedValue = String(value);
+    if (groupField === 'category') {
+        const match = options.categories.find((category) => String(category.value) === normalizedValue || category.label === normalizedValue);
+        return match ? { category: match.label } : {};
+    }
+    if (groupField === 'type') {
+        return { type: normalizedValue };
+    }
+    if (groupField === 'priority') {
+        return Number.isFinite(Number(value)) ? { priority: Number(value) } : {};
+    }
+    if (groupField === 'complexity') {
+        return Number.isFinite(Number(value)) ? { complexity: Number(value) } : {};
+    }
+    if (groupField === 'approach') {
+        const match = options.approaches.find((approach) => String(approach.value) === normalizedValue || approach.label === normalizedValue);
+        return match ? { approach: match.value, taxonomyApproach: match.value } : {};
+    }
+    if (groupField === 'assignee') {
+        if (normalizedValue.trim().length > 0) {
+            return { assignee: normalizedValue };
+        }
+        return {};
+    }
+    if (groupField === 'status') {
+        if (normalizedValue === 'completed')
+            return { status: 'done' };
+        if (normalizedValue === 'task' || normalizedValue === 'on-hold' || normalizedValue === 'in-progress' || normalizedValue === 'review' || normalizedValue === 'done' || normalizedValue === 'cancelled') {
+            return { status: normalizedValue };
+        }
+        return {};
+    }
+    if (groupField === 'schedule') {
+        if (normalizedValue === 'backlog' || normalizedValue === 'expired')
+            return {};
+        return { scheduledDate: normalizedValue };
+    }
+    return {};
+}

package/dist/utils/taskDraftDefaults.test.d.ts

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