@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/components/features/planning/PlanningOwnerDropdown.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { AssigneeIdentity } from '../../ui/AssigneeIdentity';
+import { TaxonomyDropdown } from '../../ui/TaxonomyDropdown';
+import { TASK_ASSIGNEE_UNASSIGNED_COLOR, TASK_ASSIGNEE_UNASSIGNED_ICON, } from '../../../utils/assignees';
+export function normalizePlanningOwnerOptions(options, selectedValue) {
+    const selected = String(selectedValue || '').trim();
+    const byIdentity = new Map();
+    for (const option of options) {
+        const value = String(option?.value || '').trim();
+        if (!value || value === 'unassigned')
+            continue;
+        if (typeof option.archivedAt === 'string' && option.archivedAt.trim().length > 0)
+            continue;
+        const label = String(option.label || value).trim() || value;
+        const kind = String(option.kind || '').trim().toLowerCase();
+        const username = String(option.username || '').trim().toLowerCase();
+        const identity = kind === 'agent'
+            ? `agent:${username || label.toLowerCase()}`
+            : `value:${value}`;
+        if (!byIdentity.has(identity) || value === selected) {
+            byIdentity.set(identity, { ...option, value, label });
+        }
+    }
+    return Array.from(byIdentity.values()).sort((left, right) => (left.label.localeCompare(right.label, undefined, { sensitivity: 'base' })));
+}
+export function toPlanningAssigneeOption(option) {
+    const kind = option.kind === 'agent'
+        ? 'agent'
+        : option.kind === 'member'
+            ? 'member'
+            : 'unassigned';
+    return {
+        value: option.value,
+        label: option.label,
+        icon: option.icon || (kind === 'agent' ? 'Bot' : kind === 'member' ? 'User' : TASK_ASSIGNEE_UNASSIGNED_ICON),
+        color: option.color || (kind === 'agent' ? 'var(--brand-primary)' : kind === 'member' ? 'var(--status-success)' : TASK_ASSIGNEE_UNASSIGNED_COLOR),
+        kind,
+        avatarUrl: option.avatarUrl,
+        avatarRevision: option.avatarRevision,
+        avatarUpdatedAt: option.avatarUpdatedAt,
+        username: option.username,
+        surfaceType: option.surfaceType,
+        providerMetadata: option.providerMetadata,
+        archivedAt: option.archivedAt,
+    };
+}
+export function PlanningOwnerDropdown({ value, options, leadingOptions = [], includeUnassigned = true, onChange, disabled, ariaLabel, className, }) {
+    const resolvedOptions = React.useMemo(() => {
+        const normalizedLeadingOptions = leadingOptions.map((option) => ({
+            ...option,
+            value: String(option.value || '').trim(),
+            label: String(option.label || option.value || '').trim(),
+        })).filter((option) => option.value && option.label);
+        const leadingValues = new Set(normalizedLeadingOptions.map((option) => option.value));
+        const assignableOptions = normalizePlanningOwnerOptions(options, value)
+            .filter((option) => !leadingValues.has(option.value));
+        return [
+            ...normalizedLeadingOptions,
+            ...(includeUnassigned ? [{
+                    value: '',
+                    label: 'Unassigned',
+                    icon: TASK_ASSIGNEE_UNASSIGNED_ICON,
+                    color: TASK_ASSIGNEE_UNASSIGNED_COLOR,
+                    kind: 'unassigned',
+                }] : []),
+            ...assignableOptions,
+        ];
+    }, [includeUnassigned, leadingOptions, options, value]);
+    const identityByValue = React.useMemo(() => new Map(resolvedOptions.map((option) => [option.value, toPlanningAssigneeOption(option)])), [resolvedOptions]);
+    return (_jsx(TaxonomyDropdown, { value: value, options: resolvedOptions.map((option) => ({
+            value: option.value,
+            label: option.label,
+            icon: option.icon || undefined,
+            color: option.color || undefined,
+        })), onChange: (nextValue) => onChange(String(nextValue)), disabled: disabled, ariaLabel: ariaLabel, className: className, portalPanel: true, panelAlign: "start", panelMinWidth: 240, searchable: true, searchPlaceholder: "Search owners...", noResultsText: "No owners found.", renderOptionContent: (option) => {
+            const identity = identityByValue.get(String(option.value));
+            return identity ? _jsx(AssigneeIdentity, { option: identity }) : option.label;
+        } }));
+}

package/dist/components/features/planning/PlanningTaskArrangeControl.d.ts

@@ -0,0 +1,5 @@
+import { type PlanningTaskArrangeMode } from './planningTaskArrangement';
+export declare function PlanningTaskArrangeControl({ value, onChange, }: {
+    value: PlanningTaskArrangeMode;
+    onChange: (value: PlanningTaskArrangeMode) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningTaskArrangeControl.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ArrowUpDown } from 'lucide-react';
+import { TaxonomyDropdown } from '../../ui/TaxonomyDropdown';
+import { PLANNING_TASK_ARRANGE_OPTIONS, } from './planningTaskArrangement';
+import controlStyles from './PlanningDropdownControl.module.css';
+import styles from './PlanningTaskArrangeControl.module.css';
+export function PlanningTaskArrangeControl({ value, onChange, }) {
+    const selected = PLANNING_TASK_ARRANGE_OPTIONS.find((option) => option.value === value)
+        || PLANNING_TASK_ARRANGE_OPTIONS[0];
+    return (_jsx(TaxonomyDropdown, { value: value, options: [...PLANNING_TASK_ARRANGE_OPTIONS], onChange: (nextValue) => onChange(nextValue), ariaLabel: "Arrange workstream tasks", className: controlStyles.control, portalPanel: true, panelAlign: "end", triggerContent: (_jsxs("span", { className: styles.trigger, title: selected.description, children: [_jsx(ArrowUpDown, { size: 14, "aria-hidden": "true" }), _jsx("span", { children: selected.label })] })) }));
+}

package/dist/components/features/planning/PlanningTaskCard.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { TaskStatus } from '../../../types';
+import type { TaskAssigneeOption } from '../../../utils/assignees';
+import type { PlanningTaskPreview } from './planningWorkspaceModel';
+type PlanningTaskCardProps = {
+    task: PlanningTaskPreview;
+    assigneeOption?: TaskAssigneeOption;
+    assigneeOptions?: TaskAssigneeOption[];
+    showStatusLabel: boolean;
+    onOpen?: () => void;
+    onAssigneeChange?: (assignee: string) => void | Promise<void>;
+    onStatusChange?: (status: TaskStatus) => void;
+    referenceAction?: React.ReactNode;
+    actions?: React.ReactNode;
+    feedback?: React.ReactNode;
+    referenceInteractive?: boolean;
+    compact?: boolean;
+};
+export declare function PlanningTaskCard({ task, assigneeOption, assigneeOptions, showStatusLabel, onOpen, onAssigneeChange, onStatusChange, referenceAction, actions, feedback, referenceInteractive, compact, }: PlanningTaskCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/features/planning/PlanningTaskCard.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { getStatusDefinition, resolveColor } from '../../../utils/constants';
+import { getTaskReferenceDisplayState } from '../../../utils/taskReferences';
+import { TaskStatusActions } from '../../task/TaskStatusActions';
+import { PlanningCardIdentity } from './PlanningCardIdentity';
+import { PlanningCardFooter, PlanningCardMeta, PlanningCardTitle, PlanningContextCount, PlanningReferenceBadge, } from './PlanningEntitySummary';
+import styles from './PlanningTaskCard.module.css';
+export function PlanningTaskCard({ task, assigneeOption, assigneeOptions, showStatusLabel, onOpen, onAssigneeChange, onStatusChange, referenceAction, actions, feedback, referenceInteractive = true, compact = false, }) {
+    const taskReference = getTaskReferenceDisplayState(task);
+    const referenceLabel = taskReference.label;
+    const statusDefinition = getStatusDefinition(task.status);
+    const statusLabel = statusDefinition.value === 'task'
+        ? ''
+        : (statusDefinition.shortLabel || statusDefinition.label);
+    const statusColor = resolveColor(statusDefinition.color);
+    const openLabel = referenceLabel
+        ? `Open task ${referenceLabel}: ${task.title}`
+        : `Open task ${task.title}`;
+    const handleKeyDown = (event) => {
+        if (!onOpen || (event.key !== 'Enter' && event.key !== ' '))
+            return;
+        event.preventDefault();
+        onOpen();
+    };
+    return (_jsxs("div", { className: `${styles.card} ${compact ? styles.compact : ''} ${task.isArchived ? styles.archived : ''}`.trim(), "data-task-status": statusDefinition.value, style: { '--planning-task-status-color': statusColor }, children: [_jsxs("div", { className: styles.topRow, children: [_jsxs("div", { className: styles.referenceRow, children: [referenceAction, referenceLabel ? (_jsx(PlanningReferenceBadge, { label: referenceLabel, entityType: "task", interactive: referenceInteractive, provisional: taskReference.isProvisional })) : _jsx("span", { "aria-hidden": "true" })] }), _jsxs("div", { className: styles.actions, onClick: (event) => event.stopPropagation(), children: [actions, _jsx(TaskStatusActions, { status: statusDefinition.value, disabled: Boolean(task.isArchived) || !onStatusChange, compressed: true, shortLabels: true, showLabel: showStatusLabel, archiveActionMode: "none", onStatusChange: onStatusChange })] })] }), feedback, _jsxs("div", { role: onOpen ? 'button' : undefined, tabIndex: onOpen ? 0 : undefined, className: styles.content, onClick: onOpen, onKeyDown: handleKeyDown, "aria-label": onOpen ? openLabel : undefined, children: [_jsx(PlanningCardTitle, { children: task.title }), _jsx(PlanningCardFooter, { identity: (_jsx(PlanningCardIdentity, { role: "assignee", option: assigneeOption, value: task.assignee, options: assigneeOptions, onChange: onAssigneeChange, disabled: Boolean(task.isArchived) })), children: _jsxs(PlanningCardMeta, { children: [statusLabel ? _jsxs(_Fragment, { children: [statusLabel, _jsx("span", { "aria-hidden": "true", children: " \u2022 " })] }) : null, _jsx(PlanningContextCount, { count: task.attachmentCount }), task.isArchived ? _jsxs(_Fragment, { children: [_jsx("span", { "aria-hidden": "true", children: " \u2022 " }), "archived"] }) : null] }) })] })] }));
+}

package/dist/components/features/planning/PlanningTaskOrderList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { PlanningTaskPreview } from './planningWorkspaceModel';
+import type { PlanningTaskArrangeMode } from './planningTaskArrangement';
+export declare function PlanningTaskOrderList(props: {
+    tasks: PlanningTaskPreview[];
+    mode: PlanningTaskArrangeMode;
+    onReorder?: (taskIds: string[]) => void | Promise<void>;
+    children: (task: PlanningTaskPreview) => React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningTaskOrderList.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { DndContext, KeyboardSensor, PointerSensor, closestCenter, useSensor, useSensors, } from '@dnd-kit/core';
+import { SortableContext, arrayMove, sortableKeyboardCoordinates, useSortable, verticalListSortingStrategy, } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import { GripVertical } from 'lucide-react';
+import styles from './PlanningTaskOrderList.module.css';
+function SortableTask(props) {
+    const sortable = useSortable({ id: props.task.id, disabled: props.disabled });
+    return (_jsxs("div", { ref: sortable.setNodeRef, className: styles.item, style: { transform: CSS.Transform.toString(sortable.transform), transition: sortable.transition }, children: [_jsx("button", { type: "button", className: styles.grip, disabled: props.disabled, "aria-label": `Reorder ${props.task.title}`, title: "Drag to change execution order", ...sortable.attributes, ...sortable.listeners, children: _jsx(GripVertical, { size: 15, "aria-hidden": "true" }) }), _jsx("div", { className: styles.card, children: props.children })] }));
+}
+export function PlanningTaskOrderList(props) {
+    const [orderedIds, setOrderedIds] = React.useState(() => props.tasks.map((task) => task.id));
+    const [saving, setSaving] = React.useState(false);
+    const sourceKey = props.tasks.map((task) => task.id).join('\0');
+    React.useEffect(() => setOrderedIds(props.tasks.map((task) => task.id)), [sourceKey]);
+    const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 6 } }), useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }));
+    const orderedTasks = React.useMemo(() => {
+        const byId = new Map(props.tasks.map((task) => [task.id, task]));
+        return orderedIds.map((id) => byId.get(id)).filter((task) => Boolean(task));
+    }, [orderedIds, props.tasks]);
+    const draggable = props.mode === 'execution' && Boolean(props.onReorder);
+    const handleDragEnd = React.useCallback(async (event) => {
+        if (!draggable || saving || !event.over || event.active.id === event.over.id)
+            return;
+        const previous = orderedIds;
+        const from = previous.indexOf(String(event.active.id));
+        const to = previous.indexOf(String(event.over.id));
+        if (from < 0 || to < 0)
+            return;
+        const byId = new Map(orderedTasks.map((task) => [task.id, task]));
+        const terminal = (task) => task?.status === 'done' || task?.status === 'cancelled';
+        if (terminal(byId.get(previous[from])) !== terminal(byId.get(previous[to])))
+            return;
+        const next = arrayMove(previous, from, to);
+        setOrderedIds(next);
+        setSaving(true);
+        try {
+            await props.onReorder?.(next);
+        }
+        catch {
+            setOrderedIds(previous);
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [draggable, orderedIds, orderedTasks, props, saving]);
+    if (!draggable) {
+        return _jsx("div", { className: `${styles.list} ${props.className || ''}`.trim(), children: props.tasks.map((task) => (_jsx(React.Fragment, { children: props.children(task) }, task.id))) });
+    }
+    return (_jsx(DndContext, { sensors: sensors, collisionDetection: closestCenter, onDragEnd: (event) => void handleDragEnd(event), children: _jsx(SortableContext, { items: orderedIds, strategy: verticalListSortingStrategy, children: _jsx("div", { className: `${styles.list} ${props.className || ''}`.trim(), "aria-busy": saving || undefined, children: orderedTasks.map((task) => (_jsx(SortableTask, { task: task, disabled: saving, children: props.children(task) }, task.id))) }) }) }));
+}

package/dist/components/features/planning/PlanningUnlinkConfirmation.d.ts

@@ -0,0 +1,15 @@
+import type { TaskforceTheme } from '../../../utils/theme';
+export type PlanningRelationshipUnlink = {
+    entityType: 'workstream' | 'task';
+    id: string;
+    referenceLabel: string;
+    title: string;
+    parentLabel: string;
+};
+export declare function PlanningUnlinkConfirmation({ item, busy, theme, onCancel, onConfirm, }: {
+    item: PlanningRelationshipUnlink | null;
+    busy: boolean;
+    theme?: TaskforceTheme;
+    onCancel: () => void;
+    onConfirm: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningUnlinkConfirmation.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Unlink } from 'lucide-react';
+import { Modal } from '../../ui/Modal';
+import styles from './PlanningUnlinkConfirmation.module.css';
+export function PlanningUnlinkConfirmation({ item, busy, theme, onCancel, onConfirm, }) {
+    return (_jsx(Modal, { isOpen: Boolean(item), onClose: onCancel, closeDisabled: busy, closeOnOverlayClick: false, size: "sm", theme: theme, title: (_jsxs("span", { className: styles.title, children: [_jsx(Unlink, { size: 17, "aria-hidden": "true" }), "Unlink ", item?.entityType || 'item'] })), footer: (_jsxs("div", { className: styles.actions, children: [_jsx("button", { type: "button", className: "tf-button-secondary", disabled: busy, onClick: onCancel, "data-modal-initial-focus": true, children: "Cancel" }), _jsx("button", { type: "button", className: "tf-button-destructive", disabled: busy, onClick: onConfirm, children: busy ? 'Unlinking…' : 'Unlink' })] })), children: item ? (_jsxs("div", { className: styles.content, children: [_jsxs("p", { children: ["Unlink ", _jsx("strong", { children: item.referenceLabel }), " ", item.title, " from ", item.parentLabel, "?"] }), _jsx("p", { className: styles.help, children: "The item will remain available and can be linked again later." })] })) : null }));
+}

package/dist/components/features/planning/planningCreateIntent.d.ts

@@ -0,0 +1,10 @@
+interface PlanningInitiativeReference {
+    id: string;
+    referenceNumber?: number | null;
+    title: string;
+}
+export declare function resolveWorkstreamCreateInitiativeId(initiatives: PlanningInitiativeReference[], fixedInitiativeId: string | null | undefined, draftInitiativeReference: string): {
+    initiativeId: string | null;
+    invalid: boolean;
+};
+export {};

package/dist/components/features/planning/planningCreateIntent.js

@@ -0,0 +1,16 @@
+import { resolveInitiativeReference } from '../../../utils/planningReferences';
+export function resolveWorkstreamCreateInitiativeId(initiatives, fixedInitiativeId, draftInitiativeReference) {
+    const fixedId = String(fixedInitiativeId || '').trim();
+    if (fixedId) {
+        return initiatives.some((initiative) => initiative.id === fixedId)
+            ? { initiativeId: fixedId, invalid: false }
+            : { initiativeId: null, invalid: true };
+    }
+    const draftReference = draftInitiativeReference.trim();
+    if (!draftReference)
+        return { initiativeId: null, invalid: false };
+    const resolved = resolveInitiativeReference(initiatives, draftReference);
+    return resolved
+        ? { initiativeId: resolved.id, invalid: false }
+        : { initiativeId: null, invalid: true };
+}

package/dist/components/features/planning/planningNavigator.d.ts

@@ -0,0 +1,33 @@
+import type { PlanningInitiativeSummary, PlanningNodeSummary, PlanningWorkstreamSummary } from './planningWorkspaceModel';
+export type PlanningNavigatorOwnerFilter = string;
+export type PlanningNavigatorSort = 'default' | 'title' | 'owner' | 'progress';
+export declare const PLANNING_NAVIGATOR_SORT_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+export type PlanningNavigatorInitiativeResult = {
+    initiative: PlanningInitiativeSummary;
+    workstreams: PlanningWorkstreamSummary[];
+};
+export declare function matchesPlanningNavigatorItem({ item, entityType, showArchivedPlanning, searchQuery, ownerFilter, currentOwnerId, }: {
+    item: PlanningNodeSummary;
+    entityType: 'initiative' | 'workstream';
+    showArchivedPlanning: boolean;
+    searchQuery: string;
+    ownerFilter: PlanningNavigatorOwnerFilter;
+    currentOwnerId: string;
+}): boolean;
+export declare function buildPlanningNavigatorResults({ initiatives, standaloneWorkstreams, showArchivedPlanning, searchQuery, ownerFilter, currentOwnerId, sort, }: {
+    initiatives: PlanningInitiativeSummary[];
+    standaloneWorkstreams: PlanningWorkstreamSummary[];
+    showArchivedPlanning: boolean;
+    searchQuery: string;
+    ownerFilter: PlanningNavigatorOwnerFilter;
+    currentOwnerId: string;
+    sort: PlanningNavigatorSort;
+}): {
+    initiatives: PlanningNavigatorInitiativeResult[];
+    standaloneWorkstreams: PlanningWorkstreamSummary[];
+    hasCriteria: boolean;
+    resultCount: number;
+};

package/dist/components/features/planning/planningNavigator.js

@@ -0,0 +1,96 @@
+import { formatInitiativeReference, formatWorkstreamReference, } from '../../../utils/planningReferences';
+export const PLANNING_NAVIGATOR_SORT_OPTIONS = [
+    { value: 'default', label: 'Default order' },
+    { value: 'title', label: 'Title' },
+    { value: 'owner', label: 'Owner' },
+    { value: 'progress', label: 'Progress' },
+];
+function matchesPlanningOwner(item, ownerFilter, currentOwnerId) {
+    if (ownerFilter === 'all')
+        return true;
+    const ownerId = String(item.ownerId || '').trim();
+    if (ownerFilter === 'unassigned')
+        return !ownerId;
+    if (ownerFilter === 'mine')
+        return Boolean(currentOwnerId) && ownerId === currentOwnerId;
+    return ownerId === ownerFilter;
+}
+function matchesPlanningSearch(item, entityType, normalizedQuery) {
+    if (!normalizedQuery)
+        return true;
+    const reference = entityType === 'initiative'
+        ? formatInitiativeReference(item)
+        : formatWorkstreamReference(item);
+    return item.title.toLocaleLowerCase().includes(normalizedQuery)
+        || reference.toLocaleLowerCase().includes(normalizedQuery);
+}
+export function matchesPlanningNavigatorItem({ item, entityType, showArchivedPlanning, searchQuery, ownerFilter, currentOwnerId, }) {
+    return (showArchivedPlanning || !item.isArchived)
+        && matchesPlanningOwner(item, ownerFilter, currentOwnerId.trim())
+        && matchesPlanningSearch(item, entityType, searchQuery.trim().toLocaleLowerCase());
+}
+function sortPlanningItems(items, sort) {
+    if (sort === 'default')
+        return items;
+    return items
+        .map((item, index) => ({ item, index }))
+        .sort((left, right) => {
+        let comparison = 0;
+        if (sort === 'title') {
+            comparison = left.item.title.localeCompare(right.item.title, undefined, { sensitivity: 'base' });
+        }
+        else if (sort === 'owner') {
+            const leftOwner = String(left.item.ownerLabel || '').trim();
+            const rightOwner = String(right.item.ownerLabel || '').trim();
+            if (!leftOwner && rightOwner)
+                comparison = 1;
+            else if (leftOwner && !rightOwner)
+                comparison = -1;
+            else
+                comparison = leftOwner.localeCompare(rightOwner, undefined, { sensitivity: 'base' });
+        }
+        else {
+            comparison = right.item.progressPercent - left.item.progressPercent;
+        }
+        return comparison || left.index - right.index;
+    })
+        .map(({ item }) => item);
+}
+export function buildPlanningNavigatorResults({ initiatives, standaloneWorkstreams, showArchivedPlanning, searchQuery, ownerFilter, currentOwnerId, sort, }) {
+    const normalizedQuery = searchQuery.trim().toLocaleLowerCase();
+    const hasCriteria = Boolean(normalizedQuery) || ownerFilter !== 'all';
+    const normalizedCurrentOwnerId = currentOwnerId.trim();
+    const visibleInitiatives = initiatives.filter((initiative) => showArchivedPlanning || !initiative.isArchived);
+    const initiativeResults = visibleInitiatives.flatMap((initiative) => {
+        const allWorkstreams = (initiative.allWorkstreams || initiative.workstreams)
+            .filter((workstream) => showArchivedPlanning || !workstream.isArchived);
+        if (!hasCriteria) {
+            return [{ initiative, workstreams: sortPlanningItems(allWorkstreams, sort) }];
+        }
+        const initiativeOwnerMatches = matchesPlanningOwner(initiative, ownerFilter, normalizedCurrentOwnerId);
+        const initiativeSearchMatches = matchesPlanningSearch(initiative, 'initiative', normalizedQuery);
+        const initiativeMatches = initiativeOwnerMatches && initiativeSearchMatches;
+        const ownerMatchedWorkstreams = allWorkstreams.filter((workstream) => (matchesPlanningOwner(workstream, ownerFilter, normalizedCurrentOwnerId)));
+        const matchingWorkstreams = ownerMatchedWorkstreams.filter((workstream) => (matchesPlanningSearch(workstream, 'workstream', normalizedQuery)));
+        const resultWorkstreams = initiativeMatches && normalizedQuery
+            ? ownerMatchedWorkstreams
+            : matchingWorkstreams;
+        if (!initiativeMatches && resultWorkstreams.length === 0)
+            return [];
+        return [{ initiative, workstreams: sortPlanningItems(resultWorkstreams, sort) }];
+    });
+    const initiativeResultById = new Map(initiativeResults.map((result) => [result.initiative.id, result]));
+    const sortedInitiativeResults = sortPlanningItems(initiativeResults.map(({ initiative }) => initiative), sort).map((initiative) => initiativeResultById.get(initiative.id));
+    const visibleStandaloneWorkstreams = standaloneWorkstreams.filter((workstream) => ((showArchivedPlanning || !workstream.isArchived)
+        && matchesPlanningOwner(workstream, ownerFilter, normalizedCurrentOwnerId)
+        && matchesPlanningSearch(workstream, 'workstream', normalizedQuery)));
+    const sortedStandaloneWorkstreams = sortPlanningItems(visibleStandaloneWorkstreams, sort);
+    return {
+        initiatives: sortedInitiativeResults,
+        standaloneWorkstreams: sortedStandaloneWorkstreams,
+        hasCriteria,
+        resultCount: sortedInitiativeResults.length
+            + sortedInitiativeResults.reduce((count, result) => count + result.workstreams.length, 0)
+            + sortedStandaloneWorkstreams.length,
+    };
+}

package/dist/components/features/planning/planningTaskArrangement.d.ts

@@ -0,0 +1,18 @@
+import type { PlanningTaskPreview } from './planningWorkspaceModel';
+export type PlanningTaskArrangeMode = 'execution' | 'ready' | 'priority';
+export declare const PLANNING_TASK_ARRANGE_OPTIONS: readonly ({
+    value: "execution";
+    label: string;
+    description: string;
+} | {
+    value: "ready";
+    label: string;
+    description: string;
+} | {
+    value: "priority";
+    label: string;
+    description: string;
+})[];
+export declare function normalizePlanningTaskArrangeMode(value: unknown): PlanningTaskArrangeMode;
+export declare function mergeVisiblePlanningTaskOrder(allTasks: readonly PlanningTaskPreview[], reorderedVisibleTaskIds: readonly string[]): string[];
+export declare function arrangePlanningTasks(tasks: readonly PlanningTaskPreview[], mode: PlanningTaskArrangeMode): PlanningTaskPreview[];

package/dist/components/features/planning/planningTaskArrangement.js

@@ -0,0 +1,106 @@
+import { getStatusDefinition } from '../../../utils/constants';
+export const PLANNING_TASK_ARRANGE_OPTIONS = Object.freeze([
+    { value: 'execution', label: 'Execution order', description: 'Shared order planned for this workstream.' },
+    { value: 'ready', label: 'Ready first', description: 'Shows tasks with completed prerequisites first.' },
+    { value: 'priority', label: 'Priority', description: 'Shows higher-priority tasks first.' },
+]);
+export function normalizePlanningTaskArrangeMode(value) {
+    return value === 'ready' || value === 'priority' ? value : 'execution';
+}
+export function mergeVisiblePlanningTaskOrder(allTasks, reorderedVisibleTaskIds) {
+    const visible = new Set(reorderedVisibleTaskIds);
+    if (visible.size !== reorderedVisibleTaskIds.length) {
+        throw new Error('Visible task order contains duplicate task ids.');
+    }
+    const expectedVisibleCount = allTasks.filter((task) => visible.has(task.id)).length;
+    if (expectedVisibleCount !== visible.size) {
+        throw new Error('Visible task order contains tasks outside this workstream.');
+    }
+    let visibleIndex = 0;
+    return allTasks.map((task) => (visible.has(task.id) ? reorderedVisibleTaskIds[visibleIndex++] : task.id));
+}
+function isTerminal(task) {
+    const status = getStatusDefinition(task.status).value;
+    return status === 'done' || status === 'cancelled';
+}
+function compareExecutionOrder(left, right) {
+    const leftRank = typeof left.workstreamOrder === 'number' && Number.isFinite(left.workstreamOrder)
+        ? left.workstreamOrder
+        : Number.POSITIVE_INFINITY;
+    const rightRank = typeof right.workstreamOrder === 'number' && Number.isFinite(right.workstreamOrder)
+        ? right.workstreamOrder
+        : Number.POSITIVE_INFINITY;
+    if (leftRank !== rightRank)
+        return leftRank - rightRank;
+    const createdComparison = String(left.createdAt || '').localeCompare(String(right.createdAt || ''));
+    return createdComparison || left.id.localeCompare(right.id);
+}
+function isReady(task, taskById) {
+    if (task.dependencyState)
+        return task.dependencyState === 'ready';
+    return (task.prerequisiteTaskIds || []).every((taskId) => (getStatusDefinition(taskById.get(taskId)?.status).value === 'done'));
+}
+function sortByExecutionOrder(tasks) {
+    return tasks.map((task, index) => ({ task, index })).sort((left, right) => (compareExecutionOrder(left.task, right.task) || left.index - right.index)).map(({ task }) => task);
+}
+function arrangeBlockedTasks(tasks, allTasksById) {
+    const taskIds = new Set(tasks.map((task) => task.id));
+    const dependentsByPrerequisite = new Map();
+    const indegree = new Map(tasks.map((task) => [task.id, 0]));
+    for (const task of tasks) {
+        for (const prerequisiteId of task.prerequisiteTaskIds || []) {
+            const prerequisite = allTasksById.get(prerequisiteId);
+            if (!prerequisite || isTerminal(prerequisite) || !taskIds.has(prerequisiteId))
+                continue;
+            dependentsByPrerequisite.set(prerequisiteId, [
+                ...(dependentsByPrerequisite.get(prerequisiteId) || []),
+                task.id,
+            ]);
+            indegree.set(task.id, (indegree.get(task.id) || 0) + 1);
+        }
+    }
+    const taskById = new Map(tasks.map((task) => [task.id, task]));
+    const available = sortByExecutionOrder(tasks.filter((task) => indegree.get(task.id) === 0));
+    const arranged = [];
+    while (available.length > 0) {
+        const task = available.shift();
+        arranged.push(task);
+        for (const dependentId of dependentsByPrerequisite.get(task.id) || []) {
+            const nextIndegree = (indegree.get(dependentId) || 0) - 1;
+            indegree.set(dependentId, nextIndegree);
+            if (nextIndegree === 0) {
+                const dependent = taskById.get(dependentId);
+                if (dependent) {
+                    available.push(dependent);
+                    available.sort(compareExecutionOrder);
+                }
+            }
+        }
+    }
+    if (arranged.length === tasks.length)
+        return arranged;
+    const arrangedIds = new Set(arranged.map((task) => task.id));
+    return [...arranged, ...sortByExecutionOrder(tasks.filter((task) => !arrangedIds.has(task.id)))];
+}
+export function arrangePlanningTasks(tasks, mode) {
+    const taskById = new Map(tasks.map((task) => [task.id, task]));
+    if (mode === 'ready') {
+        const active = tasks.filter((task) => !isTerminal(task));
+        const ready = sortByExecutionOrder(active.filter((task) => isReady(task, taskById)));
+        const blocked = arrangeBlockedTasks(active.filter((task) => !isReady(task, taskById)), taskById);
+        return [...ready, ...blocked, ...sortByExecutionOrder(tasks.filter(isTerminal))];
+    }
+    return tasks.map((task, index) => ({ task, index })).sort((leftEntry, rightEntry) => {
+        const left = leftEntry.task;
+        const right = rightEntry.task;
+        const terminalComparison = Number(isTerminal(left)) - Number(isTerminal(right));
+        if (terminalComparison)
+            return terminalComparison;
+        if (mode === 'priority') {
+            const priorityComparison = Number(right.priority || 0) - Number(left.priority || 0);
+            if (priorityComparison)
+                return priorityComparison;
+        }
+        return compareExecutionOrder(left, right) || leftEntry.index - rightEntry.index;
+    }).map(({ task }) => task);
+}