@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/components/views/panels/PlanningDrawer.test.js

@@ -0,0 +1,529 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+import { normalizePlanningOwnerOptions, PlanningDrawer, } from './PlanningDrawer';
+vi.mock('@dnd-kit/core', async () => {
+    const actual = await vi.importActual('@dnd-kit/core');
+    return {
+        ...actual,
+        useDndContext: () => ({ active: null }),
+        useDraggable: () => ({
+            attributes: {},
+            listeners: {},
+            setNodeRef: () => { },
+            transform: null,
+            isDragging: false,
+        }),
+        useDroppable: () => ({
+            setNodeRef: () => { },
+            isOver: false,
+        }),
+    };
+});
+const initiativeSummary = {
+    id: 'initiative-1',
+    referenceNumber: 12,
+    title: 'Platform Launch',
+    description: 'Coordinate launch work',
+    ownerLabel: null,
+    progressPercent: 0,
+    taskCount: 0,
+    completedTaskCount: 0,
+    workstreamCount: 0,
+    workstreams: [],
+};
+function renderPlanningDrawerHarness(options) {
+    const createWorkstream = vi.fn();
+    const submitEditor = vi.fn();
+    const removePlanningContextFile = options?.onRemovePlanningContextFile || vi.fn();
+    const updatePlanningContextCaption = options?.onUpdatePlanningContextCaption || vi.fn();
+    function Harness() {
+        const [editor, setEditor] = React.useState(null);
+        const [secondaryPane, setSecondaryPane] = React.useState(null);
+        const [draftTitle, setDraftTitle] = React.useState('');
+        const [draftDescription, setDraftDescription] = React.useState('');
+        const [draftOwner, setDraftOwner] = React.useState('');
+        const [draftInitiativeId, setDraftInitiativeId] = React.useState('');
+        const handleSubmitEditor = () => {
+            submitEditor();
+            if ((secondaryPane?.kind === 'editor' && secondaryPane.editor.entityType === 'workstream')
+                || editor?.entityType === 'workstream') {
+                createWorkstream({
+                    title: draftTitle.trim() || 'Untitled Workstream',
+                    initiativeId: draftInitiativeId === 'IN-12' ? initiativeSummary.id : null,
+                });
+            }
+        };
+        return (_jsx(PlanningDrawer, { open: true, initiatives: options?.initiatives ?? [initiativeSummary], standaloneWorkstreams: options?.standaloneWorkstreams ?? [], allStandaloneWorkstreams: options?.allStandaloneWorkstreams, activeInitiativeId: "", activeWorkstreamId: "", expandedInitiativeIds: new Set(['initiative-1']), detail: options?.detail ?? null, editor: editor, secondaryPane: secondaryPane, assigneeOptions: [], draftInitiativeSummary: draftInitiativeId === 'IN-12' ? initiativeSummary : null, draftTitle: draftTitle, draftDescription: draftDescription, draftOwner: draftOwner, draftInitiativeId: draftInitiativeId, onChangeDraftTitle: setDraftTitle, onChangeDraftDescription: setDraftDescription, onChangeDraftOwner: setDraftOwner, onChangeDraftInitiativeId: setDraftInitiativeId, onCollapseTreePane: () => { }, onExpandTreePane: () => { }, onCollapsePrimaryPane: () => { }, onExpandPrimaryPane: () => { }, onCollapseSecondaryPane: () => { }, onExpandSecondaryPane: () => { }, onBackFromSecondary: () => setSecondaryPane(null), treeCollapsed: false, primaryCollapsed: false, secondaryCollapsed: false, onCancelEditor: () => setEditor(null), onSubmitEditor: handleSubmitEditor, isSubmittingEditor: false, onCreateInitiative: () => { }, onCreateWorkstream: () => {
+                setSecondaryPane(null);
+                setDraftTitle('');
+                setDraftDescription('');
+                setDraftOwner('');
+                setDraftInitiativeId('');
+                setEditor({ mode: 'create', entityType: 'workstream' });
+            }, onToggleInitiative: () => { }, onSelectInitiative: () => { }, onSelectWorkstream: () => { }, onOpenInitiativeDetails: () => { }, onOpenWorkstreamDetails: () => { }, onOpenNestedWorkstreamDetails: () => { }, onEditInitiative: () => { }, onEditWorkstream: (workstreamId) => {
+                setEditor({ mode: 'edit', entityType: 'workstream', targetId: workstreamId });
+            }, onArchiveInitiative: () => { }, onUnarchiveInitiative: () => { }, onArchiveWorkstream: () => { }, onUnarchiveWorkstream: () => { }, onCreateTaskInWorkstream: () => { }, onCreateWorkstreamInInitiative: (initiativeId) => {
+                setDraftTitle('');
+                setDraftDescription('');
+                setDraftOwner('');
+                setDraftInitiativeId(initiativeId === initiativeSummary.id ? 'IN-12' : '');
+                setSecondaryPane({
+                    kind: 'editor',
+                    editor: { mode: 'create', entityType: 'workstream' },
+                });
+            }, onAssignInitiativeToWorkstream: options?.onAssignInitiativeToWorkstream || (() => { }), onRemoveTaskFromWorkstream: options?.onRemoveTaskFromWorkstream, onAttachTaskToWorkstreamByReference: options?.onAttachTaskToWorkstreamByReference, onAttachWorkstreamToInitiativeByReference: options?.onAttachWorkstreamToInitiativeByReference, onRemovePlanningContextFile: removePlanningContextFile, onUpdatePlanningContextCaption: updatePlanningContextCaption }));
+    }
+    render(_jsx(Harness, {}));
+    return { createWorkstream, removePlanningContextFile, submitEditor, updatePlanningContextCaption };
+}
+describe('normalizePlanningOwnerOptions', () => {
+    it('omits the shared unassigned option because planning stores empty owner as unassigned', () => {
+        expect(normalizePlanningOwnerOptions([
+            { value: 'unassigned', label: 'Unassigned', kind: 'unassigned' },
+            { value: 'member-1', label: 'Member One', kind: 'member' },
+        ], '')).toEqual([
+            { value: 'member-1', label: 'Member One', kind: 'member' },
+        ]);
+    });
+    it('hides archived agents and collapses active duplicate agent profiles by username', () => {
+        expect(normalizePlanningOwnerOptions([
+            { value: 'ai-profile-archived', label: 'Cascade', kind: 'agent', username: 'cascade', archivedAt: '2026-04-24T15:28:13.577Z' },
+            { value: 'ai-profile-new', label: 'Codex', kind: 'agent', username: 'codex' },
+            { value: 'ai-profile-old', label: 'Codex', kind: 'agent', username: 'codex' },
+            { value: 'member-1', label: 'Member One', kind: 'member' },
+        ], '')).toEqual([
+            { value: 'ai-profile-new', label: 'Codex', kind: 'agent', username: 'codex' },
+            { value: 'member-1', label: 'Member One', kind: 'member' },
+        ]);
+    });
+    it('keeps the selected duplicate profile as the visible option while editing', () => {
+        expect(normalizePlanningOwnerOptions([
+            { value: 'ai-profile-new', label: 'Codex', kind: 'agent', username: 'codex' },
+            { value: 'ai-profile-old', label: 'Codex', kind: 'agent', username: 'codex' },
+        ], 'ai-profile-old')).toEqual([
+            { value: 'ai-profile-old', label: 'Codex', kind: 'agent', username: 'codex' },
+        ]);
+    });
+});
+describe('PlanningDrawer workstream create submit', () => {
+    it('submits the top-level workstream create editor with Enter', async () => {
+        const user = userEvent.setup();
+        const { createWorkstream, submitEditor } = renderPlanningDrawerHarness();
+        await user.click(screen.getByRole('button', { name: 'Create workstream' }));
+        await user.type(screen.getByPlaceholderText('Content Production'), 'Release Readiness{Enter}');
+        await waitFor(() => {
+            expect(submitEditor).toHaveBeenCalledTimes(1);
+        });
+        expect(createWorkstream).toHaveBeenCalledWith({
+            title: 'Release Readiness',
+            initiativeId: null,
+        });
+    });
+    it('submits the in-initiative workstream create editor with Enter', async () => {
+        const user = userEvent.setup();
+        const { createWorkstream, submitEditor } = renderPlanningDrawerHarness({
+            detail: { type: 'initiative', item: initiativeSummary },
+        });
+        await user.click(screen.getByRole('button', { name: 'Create workstream in this initiative' }));
+        await user.type(screen.getByPlaceholderText('Content Production'), 'Execution Lane{Enter}');
+        await waitFor(() => {
+            expect(submitEditor).toHaveBeenCalledTimes(1);
+        });
+        expect(createWorkstream).toHaveBeenCalledWith({
+            title: 'Execution Lane',
+            initiativeId: 'initiative-1',
+        });
+    });
+});
+describe('PlanningDrawer context attachments', () => {
+    it('removes a workstream from an initiative from the initiative detail row action', async () => {
+        const user = userEvent.setup();
+        const onAssignInitiativeToWorkstream = vi.fn();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            initiativeId: 'initiative-1',
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 2,
+            completedTaskCount: 1,
+            tasks: [],
+        };
+        renderPlanningDrawerHarness({
+            detail: {
+                type: 'initiative',
+                item: {
+                    ...initiativeSummary,
+                    workstreamCount: 1,
+                    workstreams: [workstreamSummary],
+                },
+            },
+            onAssignInitiativeToWorkstream,
+        });
+        await user.click(screen.getByRole('button', { name: /remove from initiative/i }));
+        expect(onAssignInitiativeToWorkstream).toHaveBeenCalledWith('workstream-1', null);
+    });
+    it('removes a linked workstream from its initiative from the detail header', async () => {
+        const user = userEvent.setup();
+        const onAssignInitiativeToWorkstream = vi.fn();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            initiativeId: 'initiative-1',
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 0,
+            completedTaskCount: 0,
+            tasks: [],
+        };
+        renderPlanningDrawerHarness({
+            detail: { type: 'workstream', item: workstreamSummary },
+            onAssignInitiativeToWorkstream,
+        });
+        expect(screen.getAllByText('IN-12').length).toBeGreaterThan(0);
+        expect(screen.getByText('WS-44')).toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: /remove from initiative/i }));
+        expect(onAssignInitiativeToWorkstream).toHaveBeenCalledWith('workstream-1', null);
+    });
+    it('opens the workstream editor from the standalone workstream link action', async () => {
+        const user = userEvent.setup();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            initiativeId: null,
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 0,
+            completedTaskCount: 0,
+            tasks: [],
+        };
+        renderPlanningDrawerHarness({
+            detail: { type: 'workstream', item: workstreamSummary },
+        });
+        await user.click(screen.getByRole('button', { name: /attach to initiative/i }));
+        expect(screen.getByPlaceholderText('Paste initiative reference (e.g. IN-123)')).toBeInTheDocument();
+    });
+    it('sets a workstream initiative from the editor link action', async () => {
+        const user = userEvent.setup();
+        const onAssignInitiativeToWorkstream = vi.fn();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            initiativeId: null,
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 0,
+            completedTaskCount: 0,
+            tasks: [],
+        };
+        renderPlanningDrawerHarness({
+            detail: { type: 'workstream', item: workstreamSummary },
+            onAssignInitiativeToWorkstream,
+        });
+        await user.click(screen.getByRole('button', { name: /attach to initiative/i }));
+        await user.type(screen.getByPlaceholderText('Paste initiative reference (e.g. IN-123)'), 'IN-12');
+        await user.click(screen.getByRole('button', { name: /attach workstream to initiative/i }));
+        expect(onAssignInitiativeToWorkstream).toHaveBeenCalledWith('workstream-1');
+        expect(screen.queryByRole('button', { name: /clear initiative/i })).not.toBeInTheDocument();
+    });
+    it('attaches a task reference to the current workstream from the link action', async () => {
+        const user = userEvent.setup();
+        const onAttachTaskToWorkstreamByReference = vi.fn();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 0,
+            completedTaskCount: 0,
+            tasks: [],
+        };
+        renderPlanningDrawerHarness({
+            detail: { type: 'workstream', item: workstreamSummary },
+            onAttachTaskToWorkstreamByReference,
+        });
+        await user.type(screen.getByPlaceholderText('Paste task reference (e.g. T-123)'), 'T-863');
+        await user.click(screen.getByRole('button', { name: /attach task to workstream/i }));
+        expect(onAttachTaskToWorkstreamByReference).toHaveBeenCalledWith('workstream-1', 'T-863');
+        expect(screen.getByPlaceholderText('Paste task reference (e.g. T-123)')).toHaveValue('');
+    });
+    it('removes a task from the current workstream from the task row hierarchy action', async () => {
+        const user = userEvent.setup();
+        const onRemoveTaskFromWorkstream = vi.fn();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 1,
+            completedTaskCount: 0,
+            tasks: [{
+                    id: 'task-1',
+                    referenceNumber: 863,
+                    title: 'Investigate bootstrap timeouts',
+                    status: 'task',
+                }],
+        };
+        renderPlanningDrawerHarness({
+            detail: { type: 'workstream', item: workstreamSummary },
+            onRemoveTaskFromWorkstream,
+        });
+        await user.click(screen.getByRole('button', { name: /remove from workstream/i }));
+        expect(onRemoveTaskFromWorkstream).toHaveBeenCalledWith('task-1', 'workstream-1');
+    });
+    it('hides archived workstreams in initiative detail until the archive toggle is enabled', async () => {
+        const user = userEvent.setup();
+        const activeWorkstream = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            initiativeId: 'initiative-1',
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 2,
+            completedTaskCount: 1,
+            tasks: [],
+        };
+        const archivedWorkstream = {
+            id: 'workstream-archived',
+            referenceNumber: 45,
+            title: 'Retired Lane',
+            description: 'Completed work',
+            initiativeId: 'initiative-1',
+            ownerLabel: null,
+            progressPercent: 100,
+            taskCount: 1,
+            completedTaskCount: 1,
+            isArchived: true,
+            tasks: [],
+        };
+        renderPlanningDrawerHarness({
+            detail: {
+                type: 'initiative',
+                item: {
+                    ...initiativeSummary,
+                    workstreamCount: 1,
+                    workstreams: [activeWorkstream],
+                    allWorkstreams: [activeWorkstream, archivedWorkstream],
+                },
+            },
+        });
+        expect(screen.getByText('Execution Lane')).toBeInTheDocument();
+        expect(screen.queryByText('Retired Lane')).not.toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: /show archived workstreams/i }));
+        expect(screen.getByText('Retired Lane')).toBeInTheDocument();
+        expect(screen.getByText(/1 tasks • 100% complete • archived/i)).toBeInTheDocument();
+    });
+    it('hides archived workstreams in the planning tray until the tray toggle is enabled', async () => {
+        const user = userEvent.setup();
+        const activeWorkstream = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            initiativeId: 'initiative-1',
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 2,
+            completedTaskCount: 1,
+            tasks: [],
+        };
+        const archivedWorkstream = {
+            id: 'workstream-archived',
+            referenceNumber: 45,
+            title: 'Retired Lane',
+            description: 'Completed work',
+            initiativeId: 'initiative-1',
+            ownerLabel: null,
+            progressPercent: 100,
+            taskCount: 1,
+            completedTaskCount: 1,
+            isArchived: true,
+            tasks: [],
+        };
+        const standaloneWorkstream = {
+            id: 'workstream-standalone',
+            referenceNumber: 46,
+            title: 'Standalone Lane',
+            description: 'Independent work',
+            initiativeId: null,
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 0,
+            completedTaskCount: 0,
+            tasks: [],
+        };
+        const archivedStandaloneWorkstream = {
+            id: 'workstream-standalone-archived',
+            referenceNumber: 47,
+            title: 'Retired Standalone Lane',
+            description: 'Old independent work',
+            initiativeId: null,
+            ownerLabel: null,
+            progressPercent: 100,
+            taskCount: 1,
+            completedTaskCount: 1,
+            isArchived: true,
+            tasks: [],
+        };
+        renderPlanningDrawerHarness({
+            initiatives: [{
+                    ...initiativeSummary,
+                    workstreamCount: 1,
+                    workstreams: [activeWorkstream],
+                    allWorkstreams: [activeWorkstream, archivedWorkstream],
+                }],
+            standaloneWorkstreams: [standaloneWorkstream],
+            allStandaloneWorkstreams: [standaloneWorkstream, archivedStandaloneWorkstream],
+        });
+        expect(screen.getByText('Execution Lane')).toBeInTheDocument();
+        expect(screen.getByText('Standalone Lane')).toBeInTheDocument();
+        expect(screen.queryByText('Retired Lane')).not.toBeInTheDocument();
+        expect(screen.queryByText('Retired Standalone Lane')).not.toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: /show archived workstreams in tray/i }));
+        expect(screen.getByText('Retired Lane')).toBeInTheDocument();
+        expect(screen.getByText('Retired Standalone Lane')).toBeInTheDocument();
+        expect(screen.getAllByText(/archived/i).length).toBeGreaterThan(0);
+    });
+    it('hides archived tasks in workstream detail until the archive toggle is enabled', async () => {
+        const user = userEvent.setup();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            ownerLabel: null,
+            progressPercent: 50,
+            taskCount: 1,
+            completedTaskCount: 0,
+            tasks: [
+                {
+                    id: 'task-1',
+                    referenceNumber: 863,
+                    title: 'Investigate bootstrap timeouts',
+                    status: 'task',
+                },
+                {
+                    id: 'task-archived',
+                    referenceNumber: 864,
+                    title: 'Retired investigation',
+                    status: 'done',
+                    isArchived: true,
+                },
+            ],
+        };
+        renderPlanningDrawerHarness({
+            detail: { type: 'workstream', item: workstreamSummary },
+        });
+        expect(screen.getByText('Investigate bootstrap timeouts')).toBeInTheDocument();
+        expect(screen.queryByText('Retired investigation')).not.toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: /show archived tasks/i }));
+        expect(screen.getByText('Retired investigation')).toBeInTheDocument();
+        expect(screen.getByText(/Done • archived/i)).toBeInTheDocument();
+    });
+    it('renders workstream activity in the detail timeline', async () => {
+        const user = userEvent.setup();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            ownerLabel: null,
+            progressPercent: 50,
+            taskCount: 1,
+            completedTaskCount: 0,
+            tasks: [
+                {
+                    id: 'task-1',
+                    referenceNumber: 863,
+                    title: 'Investigate bootstrap timeouts',
+                    status: 'task',
+                },
+            ],
+            activity: [
+                {
+                    id: 'event:event-1',
+                    type: 'event',
+                    timestamp: '2026-04-28T09:00:00.000Z',
+                    event: {
+                        id: 'event-1',
+                        workspaceId: 'workspace-1',
+                        entityType: 'workstream',
+                        entityId: 'workstream-1',
+                        action: 'workstream-task-added',
+                        actor: 'user',
+                        actorType: 'human',
+                        createdAt: '2026-04-28T09:00:00.000Z',
+                        details: {
+                            taskId: 'task-1',
+                            taskTitle: 'Investigate bootstrap timeouts',
+                            changes: {
+                                workstreamId: {
+                                    from: null,
+                                    to: 'workstream-1',
+                                },
+                            },
+                        },
+                    },
+                },
+            ],
+            attachmentCount: 1,
+            attachments: [{ path: '/api/taskforce/context/spec.pdf', caption: '', timestamp: '' }],
+        };
+        renderPlanningDrawerHarness({
+            detail: { type: 'workstream', item: workstreamSummary },
+        });
+        const contextHeading = await screen.findByText('Context Documents (1)');
+        const activityHeading = screen.getByText('Recent activity (1)');
+        expect(Boolean(contextHeading.compareDocumentPosition(activityHeading) & Node.DOCUMENT_POSITION_FOLLOWING)).toBe(true);
+        expect(await screen.findByText('Task added: Investigate bootstrap timeouts')).toBeInTheDocument();
+        await user.click(screen.getByRole('button', { name: 'Recent activity (1)' }));
+        expect(screen.queryByText('Task added: Investigate bootstrap timeouts')).not.toBeInTheDocument();
+    });
+    it('wires workstream context caption and remove actions through planning callbacks', async () => {
+        const user = userEvent.setup();
+        const workstreamSummary = {
+            id: 'workstream-1',
+            referenceNumber: 44,
+            title: 'Execution Lane',
+            description: 'Ship the work',
+            ownerLabel: null,
+            progressPercent: 0,
+            taskCount: 0,
+            completedTaskCount: 0,
+            attachmentCount: 1,
+            attachments: [{ path: '/api/taskforce/context/spec.pdf', caption: '', timestamp: '' }],
+            tasks: [],
+        };
+        const removePlanningContextFile = vi.fn();
+        const updatePlanningContextCaption = vi.fn();
+        renderPlanningDrawerHarness({
+            detail: { type: 'workstream', item: workstreamSummary },
+            onRemovePlanningContextFile: removePlanningContextFile,
+            onUpdatePlanningContextCaption: updatePlanningContextCaption,
+        });
+        await user.click(screen.getByText('Context Documents (1)'));
+        fireEvent.change(screen.getByPlaceholderText('Add a label...'), {
+            target: { value: 'Brief' },
+        });
+        await user.click(screen.getByTitle('Delete'));
+        expect(updatePlanningContextCaption).toHaveBeenLastCalledWith('workstream', 'workstream-1', 0, 'Brief');
+        expect(removePlanningContextFile).toHaveBeenCalledWith('workstream', 'workstream-1', 0);
+    });
+});

package/dist/components/views/planningScope.d.ts

@@ -0,0 +1,20 @@
+export type PlanningTaskScope = 'open' | 'archived' | 'deleted';
+type PlanningWorkstreamLike = {
+    id: string;
+    initiativeId?: string | null;
+    isArchived?: boolean;
+};
+type PlanningInitiativeLike<TWorkstream extends PlanningWorkstreamLike> = {
+    id: string;
+    isArchived?: boolean;
+    workstreams: TWorkstream[];
+};
+export declare function isPlanningEntityVisibleForScope(taskScope: PlanningTaskScope, isArchived: boolean): boolean;
+export declare function scopePlanningSummaries<TWorkstream extends PlanningWorkstreamLike, TInitiative extends PlanningInitiativeLike<TWorkstream>>(initiatives: TInitiative[], workstreams: TWorkstream[], taskScope: PlanningTaskScope): {
+    initiatives: TInitiative[];
+    standaloneWorkstreams: TWorkstream[];
+    visibleWorkstreams: TWorkstream[];
+    initiativeById: Map<string, TInitiative>;
+    workstreamById: Map<string, TWorkstream>;
+};
+export {};

package/dist/components/views/planningScope.js

@@ -0,0 +1,25 @@
+export function isPlanningEntityVisibleForScope(taskScope, isArchived) {
+    if (taskScope === 'deleted')
+        return false;
+    return taskScope === 'archived' ? isArchived : !isArchived;
+}
+export function scopePlanningSummaries(initiatives, workstreams, taskScope) {
+    const scopedWorkstreams = workstreams.filter((workstream) => (isPlanningEntityVisibleForScope(taskScope, Boolean(workstream.isArchived))));
+    const visibleInitiatives = taskScope === 'deleted'
+        ? []
+        : initiatives
+            .filter((initiative) => isPlanningEntityVisibleForScope(taskScope, Boolean(initiative.isArchived)))
+            .map((initiative) => ({
+            ...initiative,
+            workstreams: scopedWorkstreams.filter((workstream) => workstream.initiativeId === initiative.id),
+        }));
+    const standaloneWorkstreams = scopedWorkstreams.filter((workstream) => !workstream.initiativeId);
+    const visibleWorkstreams = [...visibleInitiatives.flatMap((initiative) => initiative.workstreams), ...standaloneWorkstreams];
+    return {
+        initiatives: visibleInitiatives,
+        standaloneWorkstreams,
+        visibleWorkstreams,
+        initiativeById: new Map(visibleInitiatives.map((initiative) => [initiative.id, initiative])),
+        workstreamById: new Map(visibleWorkstreams.map((workstream) => [workstream.id, workstream])),
+    };
+}

package/dist/components/views/planningScope.test.d.ts

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

package/dist/components/views/planningScope.test.js

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import { isPlanningEntityVisibleForScope, scopePlanningSummaries } from './planningScope';
+describe('planningScope', () => {
+    it('hides archived entities from open scope and filters archived child workstreams out of visible initiatives', () => {
+        const archivedChild = { id: 'ws-archived', initiativeId: 'in-active', isArchived: true };
+        const activeChild = { id: 'ws-active', initiativeId: 'in-active', isArchived: false };
+        const standaloneActive = { id: 'ws-standalone', initiativeId: null, isArchived: false };
+        const archivedInitiativeChild = { id: 'ws-under-archived', initiativeId: 'in-archived', isArchived: false };
+        const scoped = scopePlanningSummaries([
+            {
+                id: 'in-active',
+                isArchived: false,
+                workstreams: [activeChild, archivedChild],
+            },
+            {
+                id: 'in-archived',
+                isArchived: true,
+                workstreams: [archivedInitiativeChild],
+            },
+            {
+                id: 'in-standalone',
+                isArchived: false,
+                workstreams: [standaloneActive],
+            },
+        ], [activeChild, archivedChild, standaloneActive, archivedInitiativeChild], 'open');
+        expect(isPlanningEntityVisibleForScope('open', false)).toBe(true);
+        expect(isPlanningEntityVisibleForScope('open', true)).toBe(false);
+        expect(scoped.initiatives.map((initiative) => initiative.id)).toEqual(['in-active', 'in-standalone']);
+        expect(scoped.initiatives.find((initiative) => initiative.id === 'in-active')?.workstreams.map((workstream) => workstream.id)).toEqual(['ws-active']);
+        expect(scoped.workstreamById.has('ws-archived')).toBe(false);
+        expect(scoped.workstreamById.has('ws-under-archived')).toBe(false);
+        expect(scoped.standaloneWorkstreams.map((workstream) => workstream.id)).toEqual(['ws-standalone']);
+    });
+    it('shows only archived entities in archived scope', () => {
+        const scoped = scopePlanningSummaries([
+            {
+                id: 'in-active',
+                isArchived: false,
+                workstreams: [{ id: 'ws-active', initiativeId: 'in-active', isArchived: false }],
+            },
+            {
+                id: 'in-archived',
+                isArchived: true,
+                workstreams: [
+                    { id: 'ws-archived', initiativeId: 'in-archived', isArchived: true },
+                    { id: 'ws-active-under-archived', initiativeId: 'in-archived', isArchived: false },
+                ],
+            },
+        ], [
+            { id: 'ws-active', initiativeId: 'in-active', isArchived: false },
+            { id: 'ws-archived', initiativeId: 'in-archived', isArchived: true },
+            { id: 'ws-active-under-archived', initiativeId: 'in-archived', isArchived: false },
+        ], 'archived');
+        expect(isPlanningEntityVisibleForScope('archived', true)).toBe(true);
+        expect(isPlanningEntityVisibleForScope('archived', false)).toBe(false);
+        expect(scoped.initiatives.map((initiative) => initiative.id)).toEqual(['in-archived']);
+        expect(scoped.initiatives[0]?.workstreams.map((workstream) => workstream.id)).toEqual(['ws-archived']);
+        expect(scoped.workstreamById.has('ws-active-under-archived')).toBe(false);
+    });
+});