@taskforcehq/taskforce 0.3.326 → 0.3.328

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);
+}

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

@@ -0,0 +1,132 @@
+import type { AttachmentItem, Comment, EntityActivityItem, PlanningEntityEvent, PlanningLoadState, TaskStatus } from '../../../types';
+import type { TaskAssigneeOption } from '../../../utils/assignees';
+import type { TaskReferenceContract } from '../../../utils/taskReferences';
+import type { TaskforceTheme } from '../../../utils/theme';
+import type { PlanningTaskArrangeMode } from './planningTaskArrangement';
+import type { PlanningIdentityColor, PlanningIdentityIcon } from '../../../shared/planningIdentity';
+export type PlanningStatusCounts = Record<TaskStatus, number>;
+export declare function shouldUsePlanningBootstrapTaskSummaries(input: {
+    taskScope: 'open' | 'archived' | 'deleted';
+    summaryCount: number;
+    loadingTasks: boolean;
+    activeTaskCount: number;
+    archiveHydrated: boolean;
+}): boolean;
+export type PlanningTaskPreview = {
+    id: string;
+    referenceNumber?: number | null;
+    localReferenceNumber?: number | null;
+    referenceLabel?: string;
+    title: string;
+    createdAt?: string | null;
+    status?: string | null;
+    priority?: number | null;
+    workstreamOrder?: number | null;
+    prerequisiteTaskIds?: string[];
+    dependencyState?: 'ready' | 'blocked' | 'invalid';
+    assignee?: string | null;
+    attachmentCount: number;
+    isArchived?: boolean;
+};
+export type PlanningNodeSummary = {
+    id: string;
+    referenceNumber?: number | null;
+    title: string;
+    description?: string;
+    ownerId?: string | null;
+    ownerLabel?: string | null;
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+    progressPercent: number;
+    taskCount: number;
+    completedTaskCount: number;
+    statusCounts?: PlanningStatusCounts;
+    workstreamCount?: number;
+    commentCount?: number;
+    attachmentCount?: number;
+    archiveReady?: boolean;
+    archiveActiveTaskCount?: number;
+    archiveActiveWorkstreamCount?: number;
+    comments?: Comment[];
+    activity?: EntityActivityItem[];
+    entityEvents?: PlanningEntityEvent[];
+    attachments?: Array<string | AttachmentItem>;
+    isArchived?: boolean;
+};
+export type PlanningWorkstreamSummary = PlanningNodeSummary & {
+    initiativeId?: string | null;
+    tasks?: PlanningTaskPreview[];
+};
+export type PlanningInitiativeSummary = PlanningNodeSummary & {
+    workstreams: PlanningWorkstreamSummary[];
+    allWorkstreams?: PlanningWorkstreamSummary[];
+};
+export type PlanningEntityHydrationState = {
+    status: 'idle' | 'loading' | 'ready' | 'error';
+    error?: string | null;
+};
+export type PlanningEntitySaveInput = {
+    title: string;
+    description: string | null;
+    ownerId?: string | null;
+    initiativeId?: string | null;
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+};
+export type PlanningLinkOption = {
+    id: string;
+    referenceLabel: string;
+    title: string;
+    meta?: string;
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+};
+export type PlanningLinkOptions = {
+    initiatives: PlanningLinkOption[];
+    workstreams: PlanningLinkOption[];
+    tasks: PlanningLinkOption[];
+};
+/**
+ * Shared, presentation-neutral planning data consumed by the contextual drawer
+ * and the dedicated Planning workspace. Selection and board scope intentionally
+ * remain outside this boundary because they are surface-specific concerns.
+ */
+export type PlanningWorkspaceModel = {
+    initiatives: PlanningInitiativeSummary[];
+    standaloneWorkstreams: PlanningWorkstreamSummary[];
+    assigneeOptions: TaskAssigneeOption[];
+    currentOwnerId: string | null;
+    currentWorkspaceId?: string | null;
+    theme?: TaskforceTheme;
+    taskReferences?: TaskReferenceContract;
+    loadState: PlanningLoadState;
+    hydrationStateByEntity?: Record<string, PlanningEntityHydrationState>;
+    hydrateEntity?: (entityType: 'initiative' | 'workstream', entityId: string) => void | Promise<void>;
+    retry: () => void;
+    openTask: (taskId: string) => void;
+    setTaskStatus?: (taskId: string, status: TaskStatus) => void;
+    setTaskAssignee?: (taskId: string, assignee: string) => void | Promise<void>;
+    linkOptions: PlanningLinkOptions;
+    assignWorkstreamToInitiative?: (workstreamId: string, initiativeReference: string | null) => boolean | void | Promise<boolean | void>;
+    assignTaskToWorkstream?: (taskId: string, workstreamId: string | null) => boolean | void | Promise<boolean | void>;
+    attachWorkstreamToInitiative?: (initiativeId: string, workstreamReference: string) => boolean | void | Promise<boolean | void>;
+    attachTaskToWorkstream?: (workstreamId: string, taskReference: string) => boolean | void | Promise<boolean | void>;
+    archiveEntity?: (entityType: 'initiative' | 'workstream', entityId: string) => boolean | Promise<boolean>;
+    unarchiveEntity?: (entityType: 'initiative' | 'workstream', entityId: string) => boolean | Promise<boolean>;
+    changeOwner?: (entityType: 'initiative' | 'workstream', entityId: string, ownerId: string) => void | Promise<void>;
+    changeIdentity?: (entityType: 'initiative' | 'workstream', entityId: string, patch: {
+        icon?: PlanningIdentityIcon | null;
+        color?: PlanningIdentityColor | null;
+    }) => void | Promise<void>;
+    createEntity?: (entityType: 'initiative' | 'workstream', input: PlanningEntitySaveInput) => Promise<{
+        id: string;
+    }>;
+    updateEntity?: (entityType: 'initiative' | 'workstream', entityId: string, input: Pick<PlanningEntitySaveInput, 'title' | 'description'>) => Promise<void>;
+    addContextFile?: (entityType: 'initiative' | 'workstream', entityId: string, file: AttachmentItem) => void;
+    removeContextFile?: (entityType: 'initiative' | 'workstream', entityId: string, index: number) => void;
+    updateContextCaption?: (entityType: 'initiative' | 'workstream', entityId: string, index: number, caption: string) => void;
+    showTaskCardStatusLabel: boolean;
+    taskArrangeMode?: PlanningTaskArrangeMode;
+    setTaskArrangeMode?: (mode: PlanningTaskArrangeMode) => void;
+    reorderWorkstreamTasks?: (workstreamId: string, taskIds: string[]) => void | Promise<void>;
+};

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

@@ -0,0 +1,5 @@
+export function shouldUsePlanningBootstrapTaskSummaries(input) {
+    return input.taskScope === 'open'
+        && input.summaryCount > 0
+        && (input.loadingTasks || input.activeTaskCount === 0 || !input.archiveHydrated);
+}

package/dist/components/features/settings/CategoryManager.js

@@ -69,7 +69,7 @@ export function CategoryManager(props) {
                                 ], onChange: (value) => {
                                     setSelectedCategoryValue(String(value));
                                     setIsCreating(false);
-                                }, disabled: isCreating, ariaLabelledBy: "category-config-label" })] }), !isCreating ? (_jsx("button", { type: "button", className: styles.browseBtn, onClick: () => setIsCreating(true), title: "Create new category", children: _jsx(Plus, { size: 18 }) })) : (_jsx("button", { type: "button", className: `${styles.browseBtn} ${styles.cancelBtnRed}`, onClick: () => setIsCreating(false), title: "Cancel creation", children: _jsx(X, { size: 18 }) }))] }), isCreating && (_jsxs("div", { className: `${styles.configItem} ${styles.marginBottom16}`, children: [_jsx("div", { className: `${styles.labelRow} ${styles.marginBottom8}`, children: _jsx("label", { className: styles.settingsLabel, children: "New Category Name" }) }), _jsxs("div", { style: { display: 'flex', gap: '8px' }, children: [_jsx("input", { type: "text", className: styles.input, placeholder: "e.g. Backend, Frontend, API...", value: newCategoryName, onChange: (e) => setNewCategoryName(e.target.value), onKeyDown: (e) => {
+                                }, disabled: isCreating, ariaLabelledBy: "category-config-label" })] }), !isCreating ? (_jsx("button", { type: "button", className: styles.browseBtn, onClick: () => setIsCreating(true), title: "Create new category", children: _jsx(Plus, { size: 18 }) })) : (_jsx("button", { type: "button", className: `${styles.browseBtn} ${styles.cancelBtnRed}`, onClick: () => setIsCreating(false), title: "Cancel creation", children: _jsx(X, { size: 18 }) }))] }), isCreating && (_jsxs("div", { className: `${styles.configItem} ${styles.marginBottom16}`, children: [_jsx("div", { className: `${styles.labelRow} ${styles.marginBottom8}`, children: _jsx("label", { className: styles.settingsLabel, children: "New Category Name" }) }), _jsxs("div", { style: { display: 'flex', gap: '8px' }, children: [_jsx("input", { type: "text", className: styles.input, placeholder: "Enter category name", value: newCategoryName, onChange: (e) => setNewCategoryName(e.target.value), onKeyDown: (e) => {
                                     if (e.key === 'Enter')
                                         handleSaveNewCategory();
                                 }, autoFocus: true }), _jsx("button", { type: "button", className: styles.saveSettingsBtn, onClick: handleSaveNewCategory, disabled: !newCategoryName.trim(), children: "Create" })] })] })), selectedCategory && !isCreating && (_jsxs("div", { className: styles.flex1, style: { overflowY: 'auto', marginRight: '-8px', paddingRight: '8px' }, children: [_jsx("div", { className: `${styles.configDivider} ${styles.marginBottom20}` }), _jsxs("div", { className: `${styles.configSection} ${styles.marginBottom20}`, children: [_jsxs("div", { className: styles.flexBetween, children: [_jsx("label", { className: `${styles.subLabel} ${styles.subLabelBlock}`, children: "General" }), !isProtectedCategory && (_jsxs("button", { type: "button", onClick: () => {
@@ -95,7 +95,7 @@ export function CategoryManager(props) {
                                                     setNewPathInput('');
                                                 }
                                             }
-                                        }, placeholder: "Add path (e.g. frontend/src/...)" }), _jsx("button", { type: "button", className: styles.browseBtn, onClick: () => {
+                                        }, placeholder: "Add path (e.g. path/to/folder)" }), _jsx("button", { type: "button", className: styles.browseBtn, onClick: () => {
                                             if (newPathInput.trim()) {
                                                 onAddPath(selectedCategory.value, newPathInput.trim());
                                                 setNewPathInput('');

package/dist/components/features/settings/TaxonomyEditor.js

@@ -80,7 +80,7 @@ export function TaxonomyEditor({ taxonomy, onUpdateTaxonomy, onRemoveTaxonomy, o
                                     if (confirm(`Retire taxonomy "${taxonomy.label}"? Existing task data will be preserved as legacy values.`)) {
                                         onRemoveTaxonomy(taxonomy.id);
                                     }
-                                }, children: [_jsx(Trash2, { size: 14, className: styles.trashIcon }), " Retire Taxonomy"] })))] }), taxonomy.status === 'retired' && (_jsx("p", { className: styles.settingsHint, style: { marginTop: '-4px', marginBottom: '16px' }, children: "This taxonomy is retired. Existing tasks keep their values, but it is hidden from normal new-task entry unless a task already uses it." })), _jsxs("div", { className: helperStyles.taxonomyGrid, children: [_jsxs("div", { className: styles.settingGroup, style: { margin: 0 }, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Display Label" }), _jsx("input", { className: styles.input, value: editingLabel, onChange: (e) => setEditingLabel(e.target.value), onBlur: () => handleUpdateTaxonomy({ label: editingLabel }), disabled: taxonomy.isSystem, placeholder: "e.g. Sprint, Phase..." })] }), _jsxs("div", { className: styles.settingGroup, style: { margin: 0 }, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Description" }), _jsx("textarea", { className: styles.textarea, value: taxonomy.description || '', onChange: (e) => handleUpdateTaxonomy({ description: e.target.value }), placeholder: "Optional guidance for when and how to use this taxonomy...", rows: 3, style: { minHeight: '88px' } })] }), _jsxs("div", { className: styles.settingGroup, style: { margin: 0 }, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Aliases" }), _jsx("input", { className: styles.input, value: editingAliasesText, onChange: (e) => setEditingAliasesText(e.target.value), onBlur: () => handleUpdateTaxonomy({ aliases: parseAliases(editingAliasesText) }), placeholder: "Optional aliases, comma-separated" })] }), _jsxs("div", { className: styles.settingGroup, style: { margin: 0 }, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Widget Type" }), _jsxs("select", { className: styles.select, value: taxonomy.widgetType, onChange: (e) => {
+                                }, children: [_jsx(Trash2, { size: 14, className: styles.trashIcon }), " Retire Taxonomy"] })))] }), taxonomy.status === 'retired' && (_jsx("p", { className: styles.settingsHint, style: { marginTop: '-4px', marginBottom: '16px' }, children: "This taxonomy is retired. Existing tasks keep their values, but it is hidden from normal new-task entry unless a task already uses it." })), _jsxs("div", { className: helperStyles.taxonomyGrid, children: [_jsxs("div", { className: styles.settingGroup, style: { margin: 0 }, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Display Label" }), _jsx("input", { className: styles.input, value: editingLabel, onChange: (e) => setEditingLabel(e.target.value), onBlur: () => handleUpdateTaxonomy({ label: editingLabel }), disabled: taxonomy.isSystem, placeholder: "Enter taxonomy name" })] }), _jsxs("div", { className: styles.settingGroup, style: { margin: 0 }, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Description" }), _jsx("textarea", { className: styles.textarea, value: taxonomy.description || '', onChange: (e) => handleUpdateTaxonomy({ description: e.target.value }), placeholder: "Optional guidance for when and how to use this taxonomy...", rows: 3, style: { minHeight: '88px' } })] }), _jsxs("div", { className: styles.settingGroup, style: { margin: 0 }, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Aliases" }), _jsx("input", { className: styles.input, value: editingAliasesText, onChange: (e) => setEditingAliasesText(e.target.value), onBlur: () => handleUpdateTaxonomy({ aliases: parseAliases(editingAliasesText) }), placeholder: "Optional aliases, comma-separated" })] }), _jsxs("div", { className: styles.settingGroup, style: { margin: 0 }, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Widget Type" }), _jsxs("select", { className: styles.select, value: taxonomy.widgetType, onChange: (e) => {
                                             const newType = e.target.value;
                                             handleUpdateTaxonomy({
                                                 widgetType: newType,

package/dist/components/features/settings/TaxonomyManager.js

@@ -94,7 +94,7 @@ export function TaxonomyManager(props) {
                                                     }, disabled: customCatalogItems[0]?.id === item.id, children: _jsx(ArrowUp, { size: 16 }) }), _jsx("button", { type: "button", className: styles.browseBtn, title: "Move taxonomy down", onClick: (event) => {
                                                         event.stopPropagation();
                                                         moveCustomTaxonomy(item.id, 1);
-                                                    }, disabled: customCatalogItems[customCatalogItems.length - 1]?.id === item.id, children: _jsx(ArrowDown, { size: 16 }) })] })] }, item.id))))] })] }), isCreating && (_jsx("div", { className: taxonomyManagerStyles.createOverlay, children: _jsxs("div", { className: taxonomyManagerStyles.createDialog, children: [_jsx("h3", { className: taxonomyManagerStyles.createDialogTitle, children: "New Taxonomy" }), _jsxs("div", { className: taxonomyManagerStyles.inputGroup, children: [_jsx("label", { className: styles.label, children: "Name" }), _jsx("input", { className: styles.input, placeholder: "e.g. Sprint, Phase", value: newTaxonomyLabel, onChange: (e) => setNewTaxonomyLabel(e.target.value), autoFocus: true })] }), _jsxs("div", { className: taxonomyManagerStyles.dialogActions, children: [_jsx("button", { className: `${styles.submitBtn} ${taxonomyManagerStyles.createSubmit}`, onClick: handleAddTaxonomy, disabled: !newTaxonomyLabel.trim(), children: "Create" }), _jsx("button", { className: `${styles.cancelBtn} ${taxonomyManagerStyles.createCancel}`, onClick: () => {
+                                                    }, disabled: customCatalogItems[customCatalogItems.length - 1]?.id === item.id, children: _jsx(ArrowDown, { size: 16 }) })] })] }, item.id))))] })] }), isCreating && (_jsx("div", { className: taxonomyManagerStyles.createOverlay, children: _jsxs("div", { className: taxonomyManagerStyles.createDialog, children: [_jsx("h3", { className: taxonomyManagerStyles.createDialogTitle, children: "New Taxonomy" }), _jsxs("div", { className: taxonomyManagerStyles.inputGroup, children: [_jsx("label", { className: styles.label, children: "Name" }), _jsx("input", { className: styles.input, placeholder: "Enter taxonomy name", value: newTaxonomyLabel, onChange: (e) => setNewTaxonomyLabel(e.target.value), autoFocus: true })] }), _jsxs("div", { className: taxonomyManagerStyles.dialogActions, children: [_jsx("button", { className: `${styles.submitBtn} ${taxonomyManagerStyles.createSubmit}`, onClick: handleAddTaxonomy, disabled: !newTaxonomyLabel.trim(), children: "Create" }), _jsx("button", { className: `${styles.cancelBtn} ${taxonomyManagerStyles.createCancel}`, onClick: () => {
                                             setIsCreating(false);
                                             setNewTaxonomyLabel('');
                                         }, children: "Cancel" })] })] }) }))] }));

package/dist/components/features/settings/TypeManager.js

@@ -46,7 +46,7 @@ export function TypeManager(props) {
                                 ], onChange: (value) => {
                                     setSelectedTypeValue(String(value));
                                     setIsCreating(false);
-                                }, disabled: isCreating, ariaLabelledBy: "type-config-label" })] }), !isCreating ? (_jsx("button", { type: "button", className: styles.browseBtn, onClick: () => setIsCreating(true), title: "Create new type", children: _jsx(Plus, { size: 18 }) })) : (_jsx("button", { type: "button", className: `${styles.browseBtn} ${styles.cancelBtnRed}`, onClick: () => setIsCreating(false), title: "Cancel creation", children: _jsx(X, { size: 18 }) }))] }), isCreating && (_jsxs("div", { className: `${styles.configItem} ${styles.marginBottom16}`, children: [_jsx("div", { className: `${styles.labelRow} ${styles.marginBottom8}`, children: _jsx("label", { className: styles.settingsLabel, children: "New Type Label" }) }), _jsxs("div", { style: { display: 'flex', gap: '8px' }, children: [_jsx("input", { type: "text", className: styles.input, placeholder: "e.g. Bug, Feature, Chore...", value: newTypeLabel, onChange: (e) => setNewTypeLabel(e.target.value), onKeyDown: (e) => {
+                                }, disabled: isCreating, ariaLabelledBy: "type-config-label" })] }), !isCreating ? (_jsx("button", { type: "button", className: styles.browseBtn, onClick: () => setIsCreating(true), title: "Create new type", children: _jsx(Plus, { size: 18 }) })) : (_jsx("button", { type: "button", className: `${styles.browseBtn} ${styles.cancelBtnRed}`, onClick: () => setIsCreating(false), title: "Cancel creation", children: _jsx(X, { size: 18 }) }))] }), isCreating && (_jsxs("div", { className: `${styles.configItem} ${styles.marginBottom16}`, children: [_jsx("div", { className: `${styles.labelRow} ${styles.marginBottom8}`, children: _jsx("label", { className: styles.settingsLabel, children: "New Type Label" }) }), _jsxs("div", { style: { display: 'flex', gap: '8px' }, children: [_jsx("input", { type: "text", className: styles.input, placeholder: "Enter type name", value: newTypeLabel, onChange: (e) => setNewTypeLabel(e.target.value), onKeyDown: (e) => {
                                     if (e.key === 'Enter')
                                         handleSaveNewType();
                                 }, autoFocus: true }), _jsx("button", { type: "button", className: styles.saveSettingsBtn, onClick: handleSaveNewType, disabled: !newTypeLabel.trim(), children: "Create" })] })] })), selectedType && !isCreating && (_jsxs("div", { className: styles.flex1, children: [_jsx("div", { className: `${styles.configDivider} ${styles.marginBottom20}` }), _jsx("div", { className: styles.flexBetweenCenter, children: _jsxs("div", { className: `${styles.flexColGap4} ${styles.flex1}`, children: [_jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Display Label" }), _jsx("input", { className: styles.input, value: editingDisplayLabel, onChange: (e) => setEditingDisplayLabel(e.target.value), onBlur: () => onUpdateDisplayLabel?.(editingDisplayLabel.trim()) }), _jsx("label", { className: `${styles.label} ${styles.inputLabel}`, children: "Label" }), _jsxs("div", { className: styles.gridConfig, children: [_jsx("input", { className: styles.input, value: editingLabel, onChange: (e) => setEditingLabel(e.target.value), onBlur: () => onUpdateType(selectedType.value, { label: editingLabel }), onKeyDown: (e) => {

package/dist/components/features/taskforceAgentAssignments/AgentBehaviorAssignments.d.ts

@@ -0,0 +1,10 @@
+import type { BehaviorReference } from '../../../shared/taskforceAgentDefinition.js';
+export declare function AgentBehaviorAssignments({ workspaceId, roleRef, skillRefs, onRoleRefChange, onSkillRefsChange, onManageRoles, onManageSkills, }: {
+    workspaceId: string;
+    roleRef: BehaviorReference | null;
+    skillRefs: BehaviorReference[];
+    onRoleRefChange: (reference: BehaviorReference | null) => void;
+    onSkillRefsChange: (references: BehaviorReference[]) => void;
+    onManageRoles: () => void;
+    onManageSkills: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/taskforceAgentAssignments/AgentBehaviorAssignments.js

@@ -0,0 +1,175 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { AlertTriangle, ArrowDown, ArrowUp, BriefcaseBusiness, Plus, Sparkles, X, } from 'lucide-react';
+import { TASKFORCE_AGENTS_MUTATED_EVENT, } from '../../../utils/taskforceAgentEvents.js';
+import { TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, } from '../../../utils/taskforceAgentSkillEvents.js';
+import taskforceStyles from '../../../Taskforce.module.css';
+import { loadAgentBehaviorCatalogs, } from './agentBehaviorCatalogApi.js';
+import styles from './AgentBehaviorAssignments.module.css';
+function revisionValue(reference) {
+    return reference.resolution === 'pinned' ? String(reference.revision ?? '') : '';
+}
+function pinReference(reference, revision) {
+    return {
+        id: reference.id,
+        resolution: 'pinned',
+        revision,
+    };
+}
+function currentReference(reference) {
+    return {
+        id: reference.id,
+        resolution: 'current',
+    };
+}
+function availableRevisions(item, reference) {
+    const revisions = (item?.revisions || [])
+        .map((candidate) => candidate.revision)
+        .filter((revision) => String(revision).trim().length > 0);
+    const selectedRevision = reference.resolution === 'pinned' ? reference.revision : undefined;
+    if (selectedRevision !== undefined
+        && !revisions.some((revision) => String(revision) === String(selectedRevision))) {
+        revisions.push(selectedRevision);
+    }
+    return revisions
+        .filter((revision, index) => revisions.findIndex((candidate) => String(candidate) === String(revision)) === index)
+        .sort((left, right) => {
+        const leftNumber = Number(left);
+        const rightNumber = Number(right);
+        if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber))
+            return rightNumber - leftNumber;
+        return String(right).localeCompare(String(left));
+    });
+}
+function selectedRevision(value) {
+    const numeric = Number(value);
+    return Number.isInteger(numeric) && String(numeric) === value ? numeric : value;
+}
+export function AgentBehaviorAssignments({ workspaceId, roleRef, skillRefs, onRoleRefChange, onSkillRefsChange, onManageRoles, onManageSkills, }) {
+    const [roles, setRoles] = useState([]);
+    const [skills, setSkills] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [loadError, setLoadError] = useState('');
+    const [skillToAdd, setSkillToAdd] = useState('');
+    const catalogLoadSequence = useRef(0);
+    const loadCatalogs = useCallback(async () => {
+        const loadSequence = ++catalogLoadSequence.current;
+        setLoading(true);
+        setLoadError('');
+        try {
+            const catalogs = await loadAgentBehaviorCatalogs(workspaceId);
+            if (loadSequence !== catalogLoadSequence.current)
+                return;
+            setRoles(catalogs.roles);
+            setSkills(catalogs.skills);
+        }
+        catch (error) {
+            if (loadSequence !== catalogLoadSequence.current)
+                return;
+            setLoadError(String(error?.message || error || 'Unable to load Role and Skill options.'));
+        }
+        finally {
+            if (loadSequence === catalogLoadSequence.current)
+                setLoading(false);
+        }
+    }, [workspaceId]);
+    useEffect(() => {
+        void loadCatalogs();
+        return () => {
+            catalogLoadSequence.current += 1;
+        };
+    }, [loadCatalogs]);
+    useEffect(() => {
+        const handleRoleMutation = (event) => {
+            const detail = event.detail;
+            if ((String(detail?.workspaceId || '').trim() || 'default') !== workspaceId)
+                return;
+            if (detail?.reason !== 'role-save' && detail?.reason !== 'role-retire' && detail?.reason !== 'role-restore')
+                return;
+            void loadCatalogs();
+        };
+        const handleSkillMutation = (event) => {
+            const detail = event.detail;
+            if ((String(detail?.workspaceId || '').trim() || 'default') !== workspaceId)
+                return;
+            void loadCatalogs();
+        };
+        window.addEventListener(TASKFORCE_AGENTS_MUTATED_EVENT, handleRoleMutation);
+        window.addEventListener(TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, handleSkillMutation);
+        return () => {
+            window.removeEventListener(TASKFORCE_AGENTS_MUTATED_EVENT, handleRoleMutation);
+            window.removeEventListener(TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, handleSkillMutation);
+        };
+    }, [loadCatalogs, workspaceId]);
+    const roleById = useMemo(() => new Map(roles.map((role) => [role.id, role])), [roles]);
+    const skillById = useMemo(() => new Map(skills.map((skill) => [skill.id, skill])), [skills]);
+    const selectedSkillIds = useMemo(() => new Set(skillRefs.map((reference) => reference.id)), [skillRefs]);
+    const activeSkillsToAdd = skills.filter((skill) => (skill.lifecycleStatus === 'active' && !selectedSkillIds.has(skill.id)));
+    const selectedRole = roleRef ? roleById.get(roleRef.id) || null : null;
+    const roleIssues = roleRef
+        ? [
+            ...(!selectedRole ? [`Role ${roleRef.id} is missing or unavailable.`] : []),
+            ...(selectedRole?.lifecycleStatus === 'retired' ? [`${selectedRole.definition.name} is retired.`] : []),
+            ...(roleRef.resolution === 'pinned'
+                && selectedRole
+                && !selectedRole.revisions.some((revision) => String(revision.revision) === String(roleRef.revision))
+                ? [`Pinned Role revision ${String(roleRef.revision)} is unavailable.`]
+                : []),
+        ]
+        : [];
+    return (_jsxs("div", { className: styles.assignments, children: [_jsxs("section", { className: styles.section, "aria-labelledby": "agent-role-heading", children: [_jsxs("div", { className: styles.sectionHeader, children: [_jsxs("div", { className: styles.sectionHeading, children: [_jsx(BriefcaseBusiness, { size: 17 }), _jsxs("div", { children: [_jsx("strong", { id: "agent-role-heading", children: "Role" }), _jsx("small", { children: "Optional reusable professional profile. An Agent can have one Role." })] })] }), _jsx("button", { type: "button", className: taskforceStyles.secondaryHeaderBtn, onClick: onManageRoles, children: "Manage Roles" })] }), _jsxs("div", { className: styles.roleControls, children: [_jsxs("label", { className: taskforceStyles.field, children: [_jsx("span", { className: taskforceStyles.label, children: "Role" }), _jsxs("select", { className: taskforceStyles.select, "aria-label": "Role", value: roleRef?.id || '', disabled: loading, onChange: (event) => {
+                                            const id = event.target.value;
+                                            onRoleRefChange(id ? { id, resolution: 'current' } : null);
+                                        }, children: [_jsx("option", { value: "", children: "No Role" }), roleRef && !selectedRole ? (_jsxs("option", { value: roleRef.id, children: ["Missing Role \u00B7 ", roleRef.id] })) : null, roles.map((role) => (_jsxs("option", { value: role.id, disabled: role.lifecycleStatus === 'retired', children: [role.definition.name, role.lifecycleStatus === 'retired' ? ' · Retired' : ''] }, role.id)))] })] }), _jsxs("label", { className: taskforceStyles.field, children: [_jsx("span", { className: taskforceStyles.label, children: "Version" }), _jsxs("select", { className: taskforceStyles.select, "aria-label": "Role version", value: roleRef?.resolution || 'current', disabled: !roleRef || !selectedRole, onChange: (event) => {
+                                            if (!roleRef || !selectedRole)
+                                                return;
+                                            if (event.target.value === 'current') {
+                                                onRoleRefChange(currentReference(roleRef));
+                                                return;
+                                            }
+                                            onRoleRefChange(pinReference(roleRef, selectedRole.currentRevision));
+                                        }, children: [_jsx("option", { value: "current", children: "Use latest" }), _jsx("option", { value: "pinned", children: "Pin revision" })] })] }), _jsxs("label", { className: taskforceStyles.field, children: [_jsx("span", { className: taskforceStyles.label, children: "Revision" }), _jsxs("select", { className: taskforceStyles.select, "aria-label": "Role pinned revision", value: roleRef ? revisionValue(roleRef) : '', disabled: !roleRef || roleRef.resolution !== 'pinned', onChange: (event) => {
+                                            if (!roleRef)
+                                                return;
+                                            onRoleRefChange(pinReference(roleRef, selectedRevision(event.target.value)));
+                                        }, children: [_jsx("option", { value: "", children: "Current" }), roleRef ? availableRevisions(selectedRole, roleRef).map((revision) => (_jsxs("option", { value: revision, children: ["Revision ", revision] }, revision))) : null] })] })] }), selectedRole?.definition.shortDescription ? (_jsx("small", { className: styles.empty, children: selectedRole.definition.shortDescription })) : null, roleIssues.map((message) => (_jsxs("div", { className: styles.issue, role: "alert", children: [_jsx(AlertTriangle, { size: 13 }), _jsxs("span", { children: [message, " Agent execution is blocked until this reference is repaired."] })] }, message)))] }), _jsxs("section", { className: styles.section, "aria-labelledby": "agent-skills-heading", children: [_jsxs("div", { className: styles.sectionHeader, children: [_jsxs("div", { className: styles.sectionHeading, children: [_jsx(Sparkles, { size: 17 }), _jsxs("div", { children: [_jsx("strong", { id: "agent-skills-heading", children: "Skills" }), _jsx("small", { children: "Composable behavior applied in this exact order. Later Skills take precedence when guidance conflicts." })] })] }), _jsx("button", { type: "button", className: taskforceStyles.secondaryHeaderBtn, onClick: onManageSkills, children: "Manage Skills" })] }), _jsxs("div", { className: styles.skillAdd, children: [_jsxs("label", { className: taskforceStyles.field, children: [_jsx("span", { className: taskforceStyles.label, children: "Add Skill" }), _jsxs("select", { className: taskforceStyles.select, "aria-label": "Skill to add", value: skillToAdd, disabled: loading || activeSkillsToAdd.length === 0, onChange: (event) => setSkillToAdd(event.target.value), children: [_jsx("option", { value: "", children: "Select a Skill" }), activeSkillsToAdd.map((skill) => (_jsx("option", { value: skill.id, children: skill.definition.name }, skill.id)))] })] }), _jsx("button", { type: "button", className: "tf-control-icon", disabled: !skillToAdd, "aria-label": "Add selected Skill", title: "Add selected Skill", onClick: () => {
+                                    if (!skillToAdd || selectedSkillIds.has(skillToAdd))
+                                        return;
+                                    onSkillRefsChange([...skillRefs, { id: skillToAdd, resolution: 'current' }]);
+                                    setSkillToAdd('');
+                                }, children: _jsx(Plus, { size: 14 }) })] }), skillRefs.length > 0 ? (_jsx("ol", { className: styles.referenceList, children: skillRefs.map((reference, index) => {
+                            const skill = skillById.get(reference.id) || null;
+                            const referenceIssues = [
+                                ...(!skill ? [`Skill ${reference.id} is missing or unavailable.`] : []),
+                                ...(skill?.lifecycleStatus === 'retired' ? [`${skill.definition.name} is retired.`] : []),
+                                ...(reference.resolution === 'pinned'
+                                    && skill
+                                    && !skill.revisions.some((revision) => String(revision.revision) === String(reference.revision))
+                                    ? [`Pinned Skill revision ${String(reference.revision)} is unavailable.`]
+                                    : []),
+                            ];
+                            return (_jsxs("li", { children: [_jsxs("div", { className: styles.referenceRow, children: [_jsxs("div", { className: styles.referenceCopy, children: [_jsxs("strong", { children: [index + 1, ". ", skill?.definition.name || `Missing Skill · ${reference.id}`] }), _jsx("small", { children: skill?.definition.shortDescription || reference.id })] }), _jsxs("select", { className: taskforceStyles.select, "aria-label": `${skill?.definition.name || reference.id} version`, value: reference.resolution, disabled: !skill, onChange: (event) => {
+                                                    const next = [...skillRefs];
+                                                    next[index] = event.target.value === 'current'
+                                                        ? currentReference(reference)
+                                                        : pinReference(reference, skill?.revision || 1);
+                                                    onSkillRefsChange(next);
+                                                }, children: [_jsx("option", { value: "current", children: "Use latest" }), _jsx("option", { value: "pinned", children: "Pin revision" })] }), _jsxs("select", { className: taskforceStyles.select, "aria-label": `${skill?.definition.name || reference.id} pinned revision`, value: revisionValue(reference), disabled: reference.resolution !== 'pinned', onChange: (event) => {
+                                                    const next = [...skillRefs];
+                                                    next[index] = pinReference(reference, selectedRevision(event.target.value));
+                                                    onSkillRefsChange(next);
+                                                }, children: [_jsx("option", { value: "", children: "Current" }), availableRevisions(skill, reference).map((revision) => (_jsxs("option", { value: revision, children: ["Revision ", revision] }, revision)))] }), _jsxs("div", { className: styles.rowActions, children: [_jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact", "aria-label": `Move ${skill?.definition.name || reference.id} up`, disabled: index === 0, onClick: () => {
+                                                            if (index === 0)
+                                                                return;
+                                                            const next = [...skillRefs];
+                                                            [next[index - 1], next[index]] = [next[index], next[index - 1]];
+                                                            onSkillRefsChange(next);
+                                                        }, children: _jsx(ArrowUp, { size: 14 }) }), _jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact", "aria-label": `Move ${skill?.definition.name || reference.id} down`, disabled: index === skillRefs.length - 1, onClick: () => {
+                                                            if (index === skillRefs.length - 1)
+                                                                return;
+                                                            const next = [...skillRefs];
+                                                            [next[index], next[index + 1]] = [next[index + 1], next[index]];
+                                                            onSkillRefsChange(next);
+                                                        }, children: _jsx(ArrowDown, { size: 14 }) }), _jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact", "aria-label": `Remove ${skill?.definition.name || reference.id}`, onClick: () => onSkillRefsChange(skillRefs.filter((_, skillIndex) => skillIndex !== index)), children: _jsx(X, { size: 14 }) })] })] }), referenceIssues.map((message) => (_jsxs("div", { className: styles.issue, role: "alert", children: [_jsx(AlertTriangle, { size: 13 }), _jsxs("span", { children: [message, " Agent execution is blocked until this reference is repaired."] })] }, message)))] }, `${reference.id}-${index}`));
+                        }) })) : (_jsx("p", { className: styles.empty, children: "No Skills selected." })), loadError ? _jsx("p", { className: styles.loadError, role: "alert", children: loadError }) : null] })] }));
+}

package/dist/components/features/taskforceAgentAssignments/agentBehaviorCatalogApi.d.ts

@@ -0,0 +1,27 @@
+export interface CatalogRevision {
+    revision: number | string;
+}
+export interface RoleCatalogItem {
+    id: string;
+    lifecycleStatus: 'active' | 'retired';
+    currentRevision: number;
+    definition: {
+        name: string;
+        shortDescription: string;
+    };
+    revisions: CatalogRevision[];
+}
+export interface SkillCatalogItem {
+    id: string;
+    lifecycleStatus: 'active' | 'retired';
+    revision: number;
+    definition: {
+        name: string;
+        shortDescription: string;
+    };
+    revisions: CatalogRevision[];
+}
+export declare function loadAgentBehaviorCatalogs(workspaceId: string): Promise<{
+    roles: RoleCatalogItem[];
+    skills: SkillCatalogItem[];
+}>;

package/dist/components/features/taskforceAgentAssignments/agentBehaviorCatalogApi.js

@@ -0,0 +1,24 @@
+export async function loadAgentBehaviorCatalogs(workspaceId) {
+    const [roleResponse, skillResponse] = await Promise.all([
+        fetch(`/api/taskforce/agent-roles?workspaceId=${encodeURIComponent(workspaceId)}&includeRetired=true`, {
+            credentials: 'include',
+        }),
+        fetch(`/api/taskforce/agent-skills?workspaceId=${encodeURIComponent(workspaceId)}&includeRetired=true`, {
+            credentials: 'include',
+        }),
+    ]);
+    const [rolePayload, skillPayload] = await Promise.all([
+        roleResponse.json().catch(() => ({})),
+        skillResponse.json().catch(() => ({})),
+    ]);
+    if (!roleResponse.ok || rolePayload?.success === false) {
+        throw new Error(String(rolePayload?.error || 'Unable to load Roles.'));
+    }
+    if (!skillResponse.ok || skillPayload?.success === false) {
+        throw new Error(String(skillPayload?.error || 'Unable to load Skills.'));
+    }
+    return {
+        roles: Array.isArray(rolePayload?.roles) ? rolePayload.roles : [],
+        skills: Array.isArray(skillPayload?.skills) ? skillPayload.skills : [],
+    };
+}