@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/documentReviews/service.js

@@ -0,0 +1,210 @@
+function normalizeId(value) {
+    return String(value || '').trim();
+}
+function normalizeCommentBody(value) {
+    return String(value || '').trim();
+}
+function normalizeStatus(value) {
+    return String(value || '').trim().toLowerCase() === 'resolved' ? 'resolved' : 'open';
+}
+function hydrateComment(deps, workspaceId, comment) {
+    return {
+        ...comment,
+        authorActor: comment.authorActorId ? deps.resolveWorkspaceActor(workspaceId, comment.authorActorId) : null,
+    };
+}
+function hydrateSession(deps, session) {
+    const comments = deps.commentStore.listForSession(session.id, session.workspaceId);
+    return {
+        ...session,
+        comments: comments
+            .filter((comment) => !comment.deletedAt)
+            .map((comment) => hydrateComment(deps, session.workspaceId, comment)),
+        createdByActor: session.createdByActorId ? deps.resolveWorkspaceActor(session.workspaceId, session.createdByActorId) : null,
+        updatedByActor: session.updatedByActorId ? deps.resolveWorkspaceActor(session.workspaceId, session.updatedByActorId) : null,
+    };
+}
+function getRequiredDocumentAsset(deps, workspaceId, assetId) {
+    const asset = deps.workspaceAssetStore?.get(assetId, workspaceId) || null;
+    if (!asset || asset.deletedAt) {
+        throw deps.createRuleError('Document asset not found.', 404, 'DOCUMENT_REVIEW_ASSET_NOT_FOUND');
+    }
+    if (asset.kind !== 'document') {
+        throw deps.createRuleError('Review sessions can only be attached to documents.', 400, 'DOCUMENT_REVIEW_DOCUMENT_REQUIRED');
+    }
+    return asset;
+}
+function nextCommentOrder(comments) {
+    return comments.reduce((maxOrder, comment) => Math.max(maxOrder, Number(comment.order || 0)), -1) + 1;
+}
+function normalizeAnchorInput(anchor) {
+    if (!anchor)
+        return null;
+    if (anchor.kind === 'document')
+        return { kind: 'document' };
+    if (anchor.kind === 'quote') {
+        const quote = String(anchor.quote || '').trim();
+        if (!quote)
+            return null;
+        return {
+            kind: 'quote',
+            quote,
+            occurrenceIndex: Number.isFinite(Number(anchor.occurrenceIndex))
+                ? Math.max(0, Math.floor(Number(anchor.occurrenceIndex)))
+                : null,
+            prefix: typeof anchor.prefix === 'string' && anchor.prefix.trim().length > 0 ? anchor.prefix.trim() : null,
+            suffix: typeof anchor.suffix === 'string' && anchor.suffix.trim().length > 0 ? anchor.suffix.trim() : null,
+        };
+    }
+    if (anchor.kind === 'line-range') {
+        const startLine = Number(anchor.startLine);
+        const endLine = Number(anchor.endLine);
+        if (!Number.isFinite(startLine) || !Number.isFinite(endLine))
+            return null;
+        const normalizedStart = Math.max(1, Math.floor(startLine));
+        const normalizedEnd = Math.max(normalizedStart, Math.floor(endLine));
+        return { kind: 'line-range', startLine: normalizedStart, endLine: normalizedEnd };
+    }
+    return null;
+}
+export function listDocumentReviewSessionsService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    return deps.sessionStore
+        .listForAsset(input.assetId, workspaceId, { includeDeleted: input.includeDeleted })
+        .map((session) => hydrateSession(deps, session));
+}
+export function getDocumentReviewSessionService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const session = deps.sessionStore.get(input.sessionId, workspaceId, { includeDeleted: input.includeDeleted });
+    return session ? hydrateSession(deps, session) : null;
+}
+export function listDocumentReviewSessionsForSyncService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    return deps.sessionStore.listByWorkspace(workspaceId, { includeDeleted: input.includeDeleted })
+        .map((session) => ({
+        ...session,
+        comments: deps.commentStore.listForSession(session.id, workspaceId, { includeDeleted: input.includeDeleted }),
+    }));
+}
+export function createDocumentReviewSessionService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const asset = getRequiredDocumentAsset(deps, workspaceId, normalizeId(input.assetId));
+    const actorId = normalizeId(input.actorId) || null;
+    const created = deps.sessionStore.create({
+        id: deps.generateEntityId('document-review-session'),
+        workspaceId,
+        assetId: asset.assetId,
+        documentId: asset.documentId,
+        documentVersion: asset.version,
+        title: typeof input.title === 'string' ? input.title : null,
+        status: normalizeStatus(input.status),
+        createdByActorId: actorId,
+        updatedByActorId: actorId,
+    });
+    return hydrateSession(deps, created);
+}
+export function updateDocumentReviewSessionService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const existing = deps.sessionStore.get(input.sessionId, workspaceId);
+    if (!existing)
+        throw deps.createRuleError('Document review session not found.', 404, 'DOCUMENT_REVIEW_SESSION_NOT_FOUND');
+    getRequiredDocumentAsset(deps, workspaceId, existing.assetId);
+    const updated = deps.sessionStore.update({
+        id: input.sessionId,
+        workspaceId,
+        title: input.title,
+        status: input.status,
+        updatedByActorId: normalizeId(input.actorId) || null,
+    });
+    return hydrateSession(deps, updated);
+}
+export function addDocumentReviewCommentService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const existing = deps.sessionStore.get(input.sessionId, workspaceId);
+    if (!existing)
+        throw deps.createRuleError('Document review session not found.', 404, 'DOCUMENT_REVIEW_SESSION_NOT_FOUND');
+    getRequiredDocumentAsset(deps, workspaceId, existing.assetId);
+    const body = normalizeCommentBody(input.body);
+    if (!body)
+        throw deps.createRuleError('Comment body is required.', 400, 'DOCUMENT_REVIEW_COMMENT_REQUIRED');
+    const now = new Date().toISOString();
+    deps.commentStore.create({
+        id: deps.generateEntityId('document-review-comment'),
+        sessionId: existing.id,
+        workspaceId,
+        order: nextCommentOrder(deps.commentStore.listForSession(existing.id, workspaceId, { includeDeleted: true })),
+        body,
+        anchor: normalizeAnchorInput(input.anchor),
+        authorActorId: normalizeId(input.actorId) || null,
+        createdAt: now,
+        updatedAt: now,
+        deletedAt: null,
+    });
+    const updated = deps.sessionStore.update({
+        id: existing.id,
+        workspaceId,
+        updatedByActorId: normalizeId(input.actorId) || null,
+        updatedAt: now,
+    });
+    return hydrateSession(deps, updated);
+}
+export function updateDocumentReviewCommentService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const existing = deps.sessionStore.get(input.sessionId, workspaceId);
+    if (!existing)
+        throw deps.createRuleError('Document review session not found.', 404, 'DOCUMENT_REVIEW_SESSION_NOT_FOUND');
+    getRequiredDocumentAsset(deps, workspaceId, existing.assetId);
+    const commentId = normalizeId(input.commentId);
+    const target = deps.commentStore.listForSession(existing.id, workspaceId, { includeDeleted: true })
+        .find((comment) => comment.id === commentId && !comment.deletedAt);
+    if (!target)
+        throw deps.createRuleError('Document review comment not found.', 404, 'DOCUMENT_REVIEW_COMMENT_NOT_FOUND');
+    const nextBody = input.body === undefined ? target.body : normalizeCommentBody(input.body);
+    if (!nextBody)
+        throw deps.createRuleError('Comment body is required.', 400, 'DOCUMENT_REVIEW_COMMENT_REQUIRED');
+    const now = new Date().toISOString();
+    deps.commentStore.update({
+        id: commentId,
+        workspaceId,
+        body: nextBody,
+        anchor: input.anchor === undefined ? undefined : normalizeAnchorInput(input.anchor),
+        updatedAt: now,
+    });
+    const updated = deps.sessionStore.update({
+        id: existing.id,
+        workspaceId,
+        updatedByActorId: normalizeId(input.actorId) || null,
+        updatedAt: now,
+    });
+    return hydrateSession(deps, updated);
+}
+export function deleteDocumentReviewCommentService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const existing = deps.sessionStore.get(input.sessionId, workspaceId);
+    if (!existing)
+        throw deps.createRuleError('Document review session not found.', 404, 'DOCUMENT_REVIEW_SESSION_NOT_FOUND');
+    getRequiredDocumentAsset(deps, workspaceId, existing.assetId);
+    const commentId = normalizeId(input.commentId);
+    const target = deps.commentStore.listForSession(existing.id, workspaceId, { includeDeleted: true })
+        .find((comment) => comment.id === commentId && !comment.deletedAt);
+    if (!target)
+        throw deps.createRuleError('Document review comment not found.', 404, 'DOCUMENT_REVIEW_COMMENT_NOT_FOUND');
+    const now = new Date().toISOString();
+    deps.commentStore.update({
+        id: commentId,
+        workspaceId,
+        updatedAt: now,
+        deletedAt: now,
+    });
+    const updated = deps.sessionStore.update({
+        id: existing.id,
+        workspaceId,
+        updatedByActorId: normalizeId(input.actorId) || null,
+        updatedAt: now,
+    });
+    return hydrateSession(deps, updated);
+}
+export function deleteDocumentReviewSessionService(deps, input) {
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    return deps.sessionStore.softDelete(input.sessionId, workspaceId);
+}

package/dist/documentReviews/types.d.ts

@@ -0,0 +1,58 @@
+import type { TaskActor } from '../core/Taskforce.js';
+export type DocumentReviewSessionStatus = 'open' | 'resolved';
+export type DocumentReviewAnchorKind = 'document' | 'quote' | 'line-range';
+export interface DocumentReviewDocumentAnchor {
+    kind: 'document';
+}
+export interface DocumentReviewQuoteAnchor {
+    kind: 'quote';
+    quote: string;
+    occurrenceIndex?: number | null;
+    prefix?: string | null;
+    suffix?: string | null;
+}
+export interface DocumentReviewLineRangeAnchor {
+    kind: 'line-range';
+    startLine: number;
+    endLine: number;
+}
+export type DocumentReviewAnchor = DocumentReviewDocumentAnchor | DocumentReviewQuoteAnchor | DocumentReviewLineRangeAnchor;
+export interface DocumentReviewCommentRecord {
+    id: string;
+    order: number;
+    body: string;
+    anchor: DocumentReviewAnchor | null;
+    authorActorId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+}
+export interface DocumentReviewCommentSyncRecord extends DocumentReviewCommentRecord {
+    tenantId: string;
+    workspaceId: string;
+    sessionId: string;
+}
+export interface DocumentReviewComment extends DocumentReviewCommentRecord {
+    authorActor: TaskActor | null;
+}
+export interface DocumentReviewSessionRecord {
+    id: string;
+    tenantId: string;
+    workspaceId: string;
+    assetId: string;
+    documentId: string | null;
+    documentVersion: number | null;
+    title: string | null;
+    status: DocumentReviewSessionStatus;
+    comments: DocumentReviewCommentRecord[];
+    createdByActorId: string | null;
+    updatedByActorId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+}
+export interface DocumentReviewSession extends DocumentReviewSessionRecord {
+    comments: DocumentReviewComment[];
+    createdByActor: TaskActor | null;
+    updatedByActor: TaskActor | null;
+}

package/dist/documentReviews/types.js

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

package/dist/hooks/auth/useAuthGuardPolicy.d.ts

@@ -0,0 +1,2 @@
+export type { AuthGuardInputs, AuthGuardPolicy } from '../authGuardPolicy';
+export { deriveAuthGuardPolicy, shouldSkipDataVersionPolling, shouldSkipDataVersionTick } from '../authGuardPolicy';

package/dist/hooks/auth/useAuthGuardPolicy.js

@@ -0,0 +1 @@
+export { deriveAuthGuardPolicy, shouldSkipDataVersionPolling, shouldSkipDataVersionTick } from '../authGuardPolicy';

package/dist/hooks/tasks/useCurrentTaskRelations.d.ts

@@ -0,0 +1,15 @@
+import type { Comment, InitiativeItem, TaskItem, WorkstreamItem } from '../../types';
+interface UseCurrentTaskRelationsInput {
+    editingTaskId: string | null;
+    relationshipTasks: TaskItem[];
+    initiatives?: InitiativeItem[];
+    workstreams?: WorkstreamItem[];
+    supplementalTasks?: TaskItem[];
+    setComments: (value: Comment[]) => void;
+}
+export declare function useCurrentTaskRelations(input: UseCurrentTaskRelationsInput): {
+    currentTask: TaskItem | undefined;
+    currentTaskWorkstream: WorkstreamItem | undefined;
+    currentTaskInitiative: InitiativeItem | undefined;
+};
+export {};

package/dist/hooks/tasks/useCurrentTaskRelations.js

@@ -0,0 +1,37 @@
+import { useEffect, useMemo } from 'react';
+export function useCurrentTaskRelations(input) {
+    const { editingTaskId, relationshipTasks, initiatives = [], workstreams = [], supplementalTasks = [], setComments } = input;
+    const availableTasks = useMemo(() => {
+        if (supplementalTasks.length === 0)
+            return relationshipTasks;
+        const byId = new Map();
+        relationshipTasks.forEach((task) => byId.set(task.id, task));
+        supplementalTasks.forEach((task) => byId.set(task.id, task));
+        return Array.from(byId.values());
+    }, [relationshipTasks, supplementalTasks]);
+    const currentTask = useMemo(() => {
+        if (!editingTaskId)
+            return undefined;
+        return availableTasks.find((task) => task.id === editingTaskId);
+    }, [availableTasks, editingTaskId]);
+    useEffect(() => {
+        if (!editingTaskId)
+            return;
+        setComments(currentTask?.comments || []);
+    }, [editingTaskId, currentTask?.id, currentTask?.updatedAt, currentTask?.comments, setComments]);
+    const currentTaskWorkstream = useMemo(() => {
+        if (!currentTask?.workstreamId)
+            return undefined;
+        return workstreams.find((workstream) => workstream.id === currentTask.workstreamId);
+    }, [currentTask, workstreams]);
+    const currentTaskInitiative = useMemo(() => {
+        if (!currentTaskWorkstream?.initiativeId)
+            return undefined;
+        return initiatives.find((initiative) => initiative.id === currentTaskWorkstream.initiativeId);
+    }, [currentTaskWorkstream, initiatives]);
+    return {
+        currentTask,
+        currentTaskWorkstream,
+        currentTaskInitiative
+    };
+}

package/dist/hooks/tasks/useTaskActions.d.ts

@@ -0,0 +1,3 @@
+import { useTaskMutations } from '../useTaskMutations';
+export type { UseTaskMutationsProps as UseTaskActionsProps } from '../useTaskMutations';
+export declare const useTaskActions: typeof useTaskMutations;

package/dist/hooks/tasks/useTaskActions.js

@@ -0,0 +1,2 @@
+import { useTaskMutations } from '../useTaskMutations';
+export const useTaskActions = useTaskMutations;

package/dist/hooks/tasks/useTaskEditorNavigation.d.ts

@@ -0,0 +1,65 @@
+import type { AttachmentItem, CategoryConfig, ChecklistItem, Comment, TaskAssignee, TaskItem, TaskStatus, TaxonomyDefinition, WorkstreamItem } from '../../types';
+type TaskforceTab = 'add' | 'tasks' | 'settings';
+interface UseTaskEditorNavigationInput {
+    activeCategories: CategoryConfig[];
+    activeTypes: Array<{
+        value: string;
+        label?: string;
+    }>;
+    activeTab: TaskforceTab;
+    attachments: Array<string | AttachmentItem>;
+    checklistItems: ChecklistItem[];
+    comments: Comment[];
+    description: string;
+    editingTaskId: string | null;
+    flushPendingAutoSave: () => Promise<void>;
+    getPreferredCategoryValue: (categories: CategoryConfig[]) => string;
+    lastUsedCategory: string;
+    newCommentText: string;
+    relationshipTasks: TaskItem[];
+    workstreams: WorkstreamItem[];
+    showArchive: boolean;
+    taxonomies: TaxonomyDefinition[];
+    setActiveTab: (tab: TaskforceTab) => void;
+    setApproach: (value: string) => void;
+    setAssignee: (value: TaskAssignee) => void;
+    setAttachments: (value: Array<string | AttachmentItem>) => void;
+    setAttachmentsDirty: (value: boolean) => void;
+    setCategory: (value: string) => void;
+    setChecklistItems: (value: ChecklistItem[]) => void;
+    setComments: (value: Comment[]) => void;
+    setComplexity: (value: number | string) => void;
+    setDescription: (value: string) => void;
+    setDueDate: (value: string) => void;
+    setEditingTaskId: (value: string | null) => void;
+    setError: (value: string) => void;
+    setFormTaxonomies: (value: Record<string, string | number | string[] | number[]>) => void;
+    setIsOpen: (value: boolean) => void;
+    setNewCommentText: (value: string) => void;
+    setPendingNavigation: (value: (() => void) | null | ((prev: (() => void) | null) => (() => void))) => void;
+    setWorkstreamInput: (value: string) => void;
+    setPriority: (value: number | string) => void;
+    setScheduledDate: (value: string) => void;
+    setShowArchive: (value: boolean) => void;
+    setStatus: (value: TaskStatus) => void;
+    setTaskReturnTrail: (value: string[] | ((prev: string[]) => string[])) => void;
+    setTitle: (value: string) => void;
+    setType: (value: string) => void;
+    setUnsavedModalOpen: (value: boolean) => void;
+    taskReturnTrail: string[];
+    title: string;
+}
+export declare function useTaskEditorNavigation(input: UseTaskEditorNavigationInput): {
+    handleNavigation: (action: () => void) => void;
+    handleClose: () => void;
+    resetForm: () => void;
+    resolveTaskIdInput: (value: string) => TaskItem | null;
+    resolveWorkstreamIdInput: (value: string) => WorkstreamItem | null;
+    handleEdit: (task: TaskItem, options?: {
+        preserveReturnTrail?: boolean;
+    }) => void;
+    handleOpenTaskById: (taskId: string) => void;
+    returnToPreviousTask: () => boolean;
+    clearReturnToParentTask: () => void;
+};
+export {};

package/dist/hooks/tasks/useTaskEditorNavigation.js

@@ -0,0 +1,235 @@
+import { useCallback } from 'react';
+import { DEFAULT_TYPE_VALUE } from '../../shared/taxonomyDefaults.js';
+import { getTaskReferenceLabel, parseTaskReference } from '../../utils/taskReferences';
+import { formatWorkstreamReference, parseWorkstreamReference } from '../../utils/planningReferences';
+import { buildDefaultFormTaxonomies } from '../../utils/taxonomyFormDefaults.js';
+export function useTaskEditorNavigation(input) {
+    const { activeCategories, activeTypes, activeTab, attachments, checklistItems, comments, description, editingTaskId, flushPendingAutoSave, getPreferredCategoryValue, lastUsedCategory, newCommentText, relationshipTasks, workstreams, showArchive, taxonomies, setActiveTab, setApproach, setAssignee, setAttachments, setAttachmentsDirty, setCategory, setChecklistItems, setComments, setComplexity, setDescription, setDueDate, setEditingTaskId, setError, setFormTaxonomies, setIsOpen, setNewCommentText, setPendingNavigation, setWorkstreamInput, setPriority, setScheduledDate, setShowArchive, setStatus, setTaskReturnTrail, setTitle, setType, setUnsavedModalOpen, taskReturnTrail, title, } = input;
+    const getPreferredTypeValue = useCallback(() => {
+        return activeTypes.find((entry) => String(entry.value || '').trim().length > 0)?.value || DEFAULT_TYPE_VALUE;
+    }, [activeTypes]);
+    const handleNavigation = useCallback((action) => {
+        if (editingTaskId) {
+            void flushPendingAutoSave();
+            action();
+            return;
+        }
+        const hasChanges = title.trim() !== '' ||
+            description.trim() !== '' ||
+            checklistItems.length > 0 ||
+            newCommentText.trim() !== '' ||
+            comments.length > 0 ||
+            attachments.length > 0;
+        if (!hasChanges) {
+            action();
+            return;
+        }
+        setPendingNavigation(() => action);
+        setUnsavedModalOpen(true);
+    }, [
+        attachments,
+        comments.length,
+        description,
+        editingTaskId,
+        flushPendingAutoSave,
+        checklistItems,
+        newCommentText,
+        setPendingNavigation,
+        setUnsavedModalOpen,
+        title,
+    ]);
+    const handleClose = useCallback(() => {
+        setIsOpen(false);
+    }, [setIsOpen]);
+    const resetForm = useCallback(() => {
+        setEditingTaskId(null);
+        setTitle('');
+        setDescription('');
+        const lastCat = lastUsedCategory;
+        const lastCatExists = activeCategories.some((category) => category.label === lastCat || category.value === lastCat);
+        if (lastCat && lastCatExists) {
+            const found = activeCategories.find((category) => category.label === lastCat || category.value === lastCat);
+            setCategory(found?.value || lastCat);
+        }
+        else {
+            setCategory(getPreferredCategoryValue(activeCategories));
+        }
+        setType(getPreferredTypeValue());
+        setPriority(2);
+        setComplexity(3);
+        setStatus('task');
+        setApproach('default');
+        setAssignee('unassigned');
+        setScheduledDate('');
+        setDueDate('');
+        setWorkstreamInput('');
+        setChecklistItems([]);
+        setFormTaxonomies(buildDefaultFormTaxonomies(taxonomies));
+        setComments([]);
+        setNewCommentText('');
+        setAttachments([]);
+        setAttachmentsDirty(false);
+        setError('');
+    }, [
+        activeCategories,
+        getPreferredCategoryValue,
+        getPreferredTypeValue,
+        lastUsedCategory,
+        setApproach,
+        setAssignee,
+        setAttachments,
+        setAttachmentsDirty,
+        setCategory,
+        setChecklistItems,
+        setComments,
+        setComplexity,
+        setDescription,
+        setDueDate,
+        setEditingTaskId,
+        setError,
+        setFormTaxonomies,
+        setNewCommentText,
+        setPriority,
+        setScheduledDate,
+        setStatus,
+        setTitle,
+        setType,
+        taxonomies
+    ]);
+    const resolveTaskIdInput = useCallback((value) => {
+        const needle = value.trim();
+        if (!needle)
+            return null;
+        const exactReferenceNumber = parseTaskReference(needle);
+        if (exactReferenceNumber) {
+            const exactReferenceMatch = relationshipTasks.find((task) => task.referenceNumber === exactReferenceNumber);
+            if (exactReferenceMatch)
+                return exactReferenceMatch;
+        }
+        const exact = relationshipTasks.find((task) => task.id === needle);
+        if (exact)
+            return exact;
+        const exactReferenceLabel = relationshipTasks.find((task) => getTaskReferenceLabel(task) === needle);
+        if (exactReferenceLabel)
+            return exactReferenceLabel;
+        return null;
+    }, [relationshipTasks]);
+    const resolveWorkstreamIdInput = useCallback((value) => {
+        const needle = value.trim();
+        if (!needle)
+            return null;
+        const normalizedNeedle = needle.toLowerCase();
+        const exactReferenceNumber = parseWorkstreamReference(needle);
+        if (exactReferenceNumber) {
+            const exactReferenceMatch = workstreams.find((workstream) => workstream.referenceNumber === exactReferenceNumber);
+            if (exactReferenceMatch)
+                return exactReferenceMatch;
+        }
+        const exact = workstreams.find((workstream) => workstream.id === needle);
+        if (exact)
+            return exact;
+        const exactTitle = workstreams.find((workstream) => workstream.title.trim().toLowerCase() === normalizedNeedle);
+        if (exactTitle)
+            return exactTitle;
+        return null;
+    }, [workstreams]);
+    const handleEdit = useCallback((task, options) => {
+        if (!options?.preserveReturnTrail) {
+            setTaskReturnTrail([]);
+        }
+        setEditingTaskId(task.id);
+        setTitle(task.title);
+        setDescription(task.description || '');
+        setCategory(task.category || getPreferredCategoryValue(activeCategories));
+        setType(task.type || getPreferredTypeValue());
+        setPriority(typeof task.priority === 'number' ? task.priority : 2);
+        setComplexity(typeof task.complexity === 'number' ? task.complexity : 3);
+        setStatus(task.status || 'task');
+        setApproach(task.approach || 'default');
+        setAssignee((task.assignee || 'unassigned'));
+        setScheduledDate(task.scheduledDate || '');
+        setDueDate(task.dueDate || '');
+        const currentWorkstream = task.workstreamId ? workstreams.find((workstream) => workstream.id === task.workstreamId) || null : null;
+        setWorkstreamInput(currentWorkstream ? (formatWorkstreamReference(currentWorkstream) || currentWorkstream.id) : '');
+        setChecklistItems(task.checklistItems || []);
+        setComments(task.comments || []);
+        setFormTaxonomies(task.taxonomies || {});
+        if (task.taxonomies?.approach) {
+            setApproach(task.taxonomies.approach);
+        }
+        setAttachments(task.attachments || []);
+        setAttachmentsDirty(false);
+        setActiveTab('add');
+    }, [
+        activeCategories,
+        getPreferredCategoryValue,
+        getPreferredTypeValue,
+        setActiveTab,
+        setApproach,
+        setAssignee,
+        setAttachments,
+        setAttachmentsDirty,
+        setCategory,
+        setChecklistItems,
+        setComments,
+        setComplexity,
+        setDescription,
+        setDueDate,
+        setEditingTaskId,
+        setFormTaxonomies,
+        setPriority,
+        setScheduledDate,
+        setStatus,
+        setTaskReturnTrail,
+        setTitle,
+        setType,
+        workstreams
+    ]);
+    const handleOpenTaskById = useCallback((taskId) => {
+        const target = relationshipTasks.find((task) => task.id === taskId);
+        if (!target)
+            return;
+        if (activeTab === 'add' && editingTaskId && editingTaskId !== target.id) {
+            setTaskReturnTrail((prev) => prev[prev.length - 1] === editingTaskId ? prev : [...prev, editingTaskId]);
+        }
+        if (target.isArchived && !showArchive) {
+            setShowArchive(true);
+        }
+        handleEdit(target, { preserveReturnTrail: true });
+    }, [activeTab, editingTaskId, handleEdit, relationshipTasks, setShowArchive, setTaskReturnTrail, showArchive]);
+    const returnToPreviousTask = useCallback(() => {
+        if (activeTab !== 'add' || !editingTaskId || taskReturnTrail.length === 0)
+            return false;
+        const nextTrail = [...taskReturnTrail];
+        while (nextTrail.length > 0) {
+            const previousTaskId = nextTrail.pop();
+            if (!previousTaskId)
+                continue;
+            const previousTask = relationshipTasks.find((task) => task.id === previousTaskId);
+            if (!previousTask)
+                continue;
+            if (previousTask.isArchived && !showArchive) {
+                setShowArchive(true);
+            }
+            setTaskReturnTrail(nextTrail);
+            handleEdit(previousTask, { preserveReturnTrail: true });
+            return true;
+        }
+        setTaskReturnTrail([]);
+        return false;
+    }, [activeTab, editingTaskId, handleEdit, relationshipTasks, setShowArchive, setTaskReturnTrail, showArchive, taskReturnTrail]);
+    const clearReturnToParentTask = useCallback(() => {
+        setTaskReturnTrail([]);
+    }, [setTaskReturnTrail]);
+    return {
+        handleNavigation,
+        handleClose,
+        resetForm,
+        resolveTaskIdInput,
+        resolveWorkstreamIdInput,
+        handleEdit,
+        handleOpenTaskById,
+        returnToPreviousTask,
+        clearReturnToParentTask
+    };
+}

package/dist/hooks/tasks/useTaskFilters.d.ts

@@ -0,0 +1,2 @@
+import { useFilterSort } from '../useFilterSort';
+export declare const useTaskFilters: typeof useFilterSort;

package/dist/hooks/tasks/useTaskFilters.js

@@ -0,0 +1,2 @@
+import { useFilterSort } from '../useFilterSort';
+export const useTaskFilters = useFilterSort;