@taskforcehq/taskforce 0.3.168

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

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Plus, List, ChevronRight, Settings2, ArrowLeft } from 'lucide-react';
+import styles from '../../../Taskforce.module.css';
+import { TaxonomyEditor } from './TaxonomyEditor';
+import { CategoryManager } from './CategoryManager';
+import { TypeManager } from './TypeManager';
+export function TaxonomyManager(props) {
+    const { taxonomies, onUpdateTaxonomies, categories, pathValidation, onUpdateCategory, onRemoveCategory, onSaveCategory, onAddPath, onRemovePath, onUpdateCategoryIcon, onUpdateCategoryColor, onBrowseFolders, types, onSaveType, onRemoveType, priorities, onUpdatePriorities, approaches, onUpdateApproaches, initialTab } = props;
+    const [activeTaxonomyId, setActiveTaxonomyId] = useState(initialTab || '');
+    const [view, setView] = useState(initialTab ? 'detail' : 'list');
+    const [isCreating, setIsCreating] = useState(false);
+    const [newTaxonomyLabel, setNewTaxonomyLabel] = useState('');
+    const handleAddTaxonomy = () => {
+        if (!newTaxonomyLabel.trim())
+            return;
+        const id = newTaxonomyLabel.toLowerCase().trim().replace(/\s+/g, '-');
+        if (taxonomies.some(t => t.id === id)) {
+            alert('A taxonomy with this ID already exists');
+            return;
+        }
+        const newTaxonomy = {
+            id,
+            label: newTaxonomyLabel.trim(),
+            options: [],
+            widgetType: 'select',
+            isSystem: false,
+            multiSelect: false,
+        };
+        onUpdateTaxonomies([...taxonomies, newTaxonomy]);
+        setNewTaxonomyLabel('');
+        setIsCreating(false);
+        setActiveTaxonomyId(id);
+        setView('detail');
+    };
+    const handleUpdateTaxonomy = (updated) => {
+        onUpdateTaxonomies(taxonomies.map(t => t.id === updated.id ? updated : t));
+    };
+    const handleRemoveTaxonomy = (id) => {
+        const updated = taxonomies.filter(t => t.id !== id);
+        onUpdateTaxonomies(updated);
+        setView('list');
+    };
+    const handleSelectTaxonomy = (id) => {
+        setActiveTaxonomyId(id);
+        setView('detail');
+    };
+    const activeTaxonomy = taxonomies.find(t => t.id === activeTaxonomyId);
+    if (view === 'list') {
+        return (_jsxs("div", { className: styles.taxonomyDrillDown, children: [_jsxs("div", { className: styles.drillDownList, children: [_jsxs("div", { className: styles.drillDownSection, children: [_jsx("h4", { className: styles.drillDownSectionTitle, children: "System Taxonomies" }), _jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy('categories'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Categories" }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [categories.length, " configured"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }), _jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy('types'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Task Types" }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [types.length, " active"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }), _jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy('priorities'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Priority Levels" }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [priorities.length, " levels"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }), _jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy('approaches'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Approach Options" }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [approaches.length, " options"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] })] }), _jsxs("div", { className: styles.drillDownSection, children: [_jsxs("div", { className: styles.drillDownSectionHeader, children: [_jsx("h4", { className: styles.drillDownSectionTitle, children: "Custom Taxonomies" }), _jsxs("button", { className: styles.addTaxonomyBtnSmall, onClick: () => setIsCreating(true), title: "Add Custom Taxonomy", children: [_jsx(Plus, { size: 14 }), " New"] })] }), taxonomies.length === 0 ? (_jsx("div", { className: styles.emptyState, children: _jsx("p", { children: "No custom taxonomies yet." }) })) : (taxonomies.map(t => (_jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy(t.id), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(List, { size: 16 }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: t.label }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [t.options.length, " options"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }, t.id))))] })] }), isCreating && (_jsx("div", { className: styles.createOverlay, children: _jsxs("div", { className: styles.createDialog, children: [_jsx("h3", { children: "New Taxonomy" }), _jsxs("div", { className: styles.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: styles.dialogActions, children: [_jsx("button", { className: styles.submitBtn, onClick: handleAddTaxonomy, disabled: !newTaxonomyLabel.trim(), children: "Create" }), _jsx("button", { className: styles.cancelBtn, onClick: () => {
+                                            setIsCreating(false);
+                                            setNewTaxonomyLabel('');
+                                        }, children: "Cancel" })] })] }) }))] }));
+    }
+    return (_jsxs("div", { className: styles.taxonomyDetailView, children: [_jsx("div", { className: styles.detailHeader, children: _jsxs("div", { className: styles.taxonomyBreadcrumbs, children: [_jsxs("button", { className: styles.breadcrumbPrev, onClick: () => setView('list'), title: "Back to All Taxonomies", children: [_jsx(ArrowLeft, { size: 16, style: { marginRight: '6px' } }), "Taxonomies"] }), _jsx(ChevronRight, { size: 14, className: styles.breadcrumbDivider }), _jsx("h3", { className: styles.breadcrumbActive, children: activeTaxonomyId === 'categories' ? 'Categories' :
+                                activeTaxonomyId === 'types' ? 'Task Types' :
+                                    activeTaxonomyId === 'priorities' ? 'Priority Levels' :
+                                        activeTaxonomyId === 'complexities' ? 'Complexity Levels' :
+                                            activeTaxonomyId === 'approaches' ? 'Approach Options' :
+                                                activeTaxonomy?.label || 'Taxonomy' })] }) }), _jsx("div", { className: styles.detailContent, children: activeTaxonomyId === 'categories' ? (_jsx(CategoryManager, { categories: categories, pathValidation: pathValidation, onUpdateCategory: onUpdateCategory, onRemoveCategory: onRemoveCategory, onSaveCategory: onSaveCategory, onAddPath: onAddPath, onRemovePath: onRemovePath, onUpdateCategoryIcon: onUpdateCategoryIcon, onUpdateCategoryColor: onUpdateCategoryColor, onBrowseFolders: onBrowseFolders })) : activeTaxonomyId === 'types' ? (_jsx(TypeManager, { types: types, onSaveType: onSaveType, onRemoveType: onRemoveType })) : activeTaxonomy ? (_jsx(TaxonomyEditor, { taxonomy: activeTaxonomy, onUpdateTaxonomy: handleUpdateTaxonomy, onRemoveTaxonomy: handleRemoveTaxonomy })) : activeTaxonomyId === 'priorities' ? (_jsx(TaxonomyEditor, { taxonomy: {
+                        id: 'priorities',
+                        label: 'Priority Levels',
+                        isSystem: true,
+                        widgetType: 'level',
+                        multiSelect: false,
+                        options: priorities
+                    }, onUpdateTaxonomy: (updated) => onUpdatePriorities(updated.options) })) : activeTaxonomyId === 'approaches' ? (_jsx(TaxonomyEditor, { taxonomy: {
+                        id: 'approaches',
+                        label: 'Approach Options',
+                        isSystem: true,
+                        widgetType: 'select',
+                        multiSelect: false,
+                        options: approaches
+                    }, onUpdateTaxonomy: (updated) => onUpdateApproaches(updated.options) })) : (_jsxs("div", { className: styles.emptyState, children: [_jsx("p", { children: "Taxonomy not found." }), _jsx("button", { className: styles.submitBtn, onClick: () => setView('list'), children: "Return to List" })] })) })] }));
+}

package/dist/components/features/settings/TaxonomyManager.d.ts

@@ -0,0 +1,54 @@
+import type { TaxonomyDefinition, CategoryConfig } from '../../../types';
+interface TaxonomyManagerProps {
+    taxonomies: TaxonomyDefinition[];
+    onUpdateTaxonomies: (taxonomies: TaxonomyDefinition[]) => void;
+    categories: CategoryConfig[];
+    pathValidation: Record<string, {
+        exists: boolean;
+        isDirectory: boolean;
+        isFile: boolean;
+    }>;
+    onUpdateCategory: (category: CategoryConfig, oldLabel?: string) => void;
+    onRemoveCategory: (value: string) => void;
+    onSaveCategory: (newCategory: string) => void;
+    onAddPath: (catValue: string, path: string) => void;
+    onRemovePath: (catValue: string, path: string) => void;
+    onUpdateCategoryIcon: (catValue: string, iconName: string) => void;
+    onUpdateCategoryColor: (catValue: string, color: string) => void;
+    onBrowseFolders: (catValue: string) => void;
+    types: {
+        value: string;
+        label: string;
+    }[];
+    onSaveType: (label: string) => void;
+    onRemoveType: (value: string) => void;
+    priorities: Array<{
+        value: number;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>;
+    onUpdatePriorities: (priorities: Array<{
+        value: number;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>) => void;
+    approaches: Array<{
+        value: string;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>;
+    onUpdateApproaches: (approaches: Array<{
+        value: string;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>) => void;
+    manualComplexityEnabled: boolean;
+    onManualComplexityEnabledChange: (enabled: boolean) => Promise<void> | void;
+    initialTab?: 'categories' | 'types' | 'priorities' | 'complexities' | 'approaches' | null;
+}
+export declare function TaxonomyManager(props: TaxonomyManagerProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,77 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Plus, List, ChevronRight, Settings2, ArrowLeft } from 'lucide-react';
+import styles from '../../../Taskforce.module.css';
+import { TaxonomyEditor } from './TaxonomyEditor';
+import { CategoryManager } from './CategoryManager';
+import { TypeManager } from './TypeManager';
+export function TaxonomyManager(props) {
+    const { taxonomies, onUpdateTaxonomies, categories, pathValidation, onUpdateCategory, onRemoveCategory, onSaveCategory, onAddPath, onRemovePath, onUpdateCategoryIcon, onUpdateCategoryColor, onBrowseFolders, types, onSaveType, onRemoveType, priorities, onUpdatePriorities, approaches, onUpdateApproaches, manualComplexityEnabled, onManualComplexityEnabledChange, initialTab } = props;
+    const [activeTaxonomyId, setActiveTaxonomyId] = useState(initialTab || '');
+    const [view, setView] = useState(initialTab ? 'detail' : 'list');
+    const [isCreating, setIsCreating] = useState(false);
+    const [newTaxonomyLabel, setNewTaxonomyLabel] = useState('');
+    const handleAddTaxonomy = () => {
+        if (!newTaxonomyLabel.trim())
+            return;
+        const id = newTaxonomyLabel.toLowerCase().trim().replace(/\s+/g, '-');
+        if (taxonomies.some(t => t.id === id)) {
+            alert('A taxonomy with this ID already exists');
+            return;
+        }
+        const newTaxonomy = {
+            id,
+            label: newTaxonomyLabel.trim(),
+            options: [],
+            widgetType: 'select',
+            isSystem: false,
+            multiSelect: false,
+        };
+        onUpdateTaxonomies([...taxonomies, newTaxonomy]);
+        setNewTaxonomyLabel('');
+        setIsCreating(false);
+        setActiveTaxonomyId(id);
+        setView('detail');
+    };
+    const handleUpdateTaxonomy = (updated) => {
+        onUpdateTaxonomies(taxonomies.map(t => t.id === updated.id ? updated : t));
+    };
+    const handleRemoveTaxonomy = (id) => {
+        const updated = taxonomies.filter(t => t.id !== id);
+        onUpdateTaxonomies(updated);
+        setView('list');
+    };
+    const handleSelectTaxonomy = (id) => {
+        setActiveTaxonomyId(id);
+        setView('detail');
+    };
+    const activeTaxonomy = taxonomies.find(t => t.id === activeTaxonomyId);
+    if (view === 'list') {
+        return (_jsxs("div", { className: styles.taxonomyDrillDown, children: [_jsxs("div", { className: styles.drillDownList, children: [_jsxs("div", { className: styles.drillDownSection, children: [_jsx("h4", { className: styles.drillDownSectionTitle, children: "System Taxonomies" }), _jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy('categories'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Categories" }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [categories.length, " configured"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }), _jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy('types'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Task Types" }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [types.length, " active"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }), _jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy('priorities'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Priority Levels" }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [priorities.length, " levels"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }), _jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy('approaches'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Approach Options" }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [approaches.length, " options"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }), _jsxs("button", { className: `${styles.drillDownItem} ${!manualComplexityEnabled ? styles.drillDownItemDimmed : ''}`, onClick: () => handleSelectTaxonomy('complexities'), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(Settings2, { size: 16, className: styles.systemIcon }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: "Complexity" }), _jsx("span", { className: styles.drillDownItemSubtext, children: manualComplexityEnabled ? 'Enabled' : 'Disabled (default)' })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] })] }), _jsxs("div", { className: styles.drillDownSection, children: [_jsxs("div", { className: styles.drillDownSectionHeader, children: [_jsx("h4", { className: styles.drillDownSectionTitle, children: "Custom Taxonomies" }), _jsxs("button", { className: styles.addTaxonomyBtnSmall, onClick: () => setIsCreating(true), title: "Add Custom Taxonomy", children: [_jsx(Plus, { size: 14 }), " New"] })] }), taxonomies.length === 0 ? (_jsx("div", { className: styles.emptyState, children: _jsx("p", { children: "No custom taxonomies yet." }) })) : (taxonomies.map(t => (_jsxs("button", { className: styles.drillDownItem, onClick: () => handleSelectTaxonomy(t.id), children: [_jsxs("div", { className: styles.drillDownItemInfo, children: [_jsx(List, { size: 16 }), _jsxs("div", { className: styles.drillDownItemText, children: [_jsx("span", { className: styles.drillDownItemLabel, children: t.label }), _jsxs("span", { className: styles.drillDownItemSubtext, children: [t.options.length, " options"] })] })] }), _jsx(ChevronRight, { size: 16, className: styles.chevron })] }, t.id))))] })] }), isCreating && (_jsx("div", { className: styles.createOverlay, children: _jsxs("div", { className: styles.createDialog, children: [_jsx("h3", { children: "New Taxonomy" }), _jsxs("div", { className: styles.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: styles.dialogActions, children: [_jsx("button", { className: styles.submitBtn, onClick: handleAddTaxonomy, disabled: !newTaxonomyLabel.trim(), children: "Create" }), _jsx("button", { className: styles.cancelBtn, onClick: () => {
+                                            setIsCreating(false);
+                                            setNewTaxonomyLabel('');
+                                        }, children: "Cancel" })] })] }) }))] }));
+    }
+    return (_jsxs("div", { className: styles.taxonomyDetailView, children: [_jsx("div", { className: styles.detailHeader, children: _jsxs("div", { className: styles.taxonomyBreadcrumbs, children: [_jsxs("button", { className: styles.breadcrumbPrev, onClick: () => setView('list'), title: "Back to All Taxonomies", children: [_jsx(ArrowLeft, { size: 16, style: { marginRight: '6px' } }), "Taxonomies"] }), _jsx(ChevronRight, { size: 14, className: styles.breadcrumbDivider }), _jsx("h3", { className: styles.breadcrumbActive, children: activeTaxonomyId === 'categories' ? 'Categories' :
+                                activeTaxonomyId === 'types' ? 'Task Types' :
+                                    activeTaxonomyId === 'priorities' ? 'Priority Levels' :
+                                        activeTaxonomyId === 'complexities' ? 'Complexity' :
+                                            activeTaxonomyId === 'approaches' ? 'Approach Options' :
+                                                activeTaxonomy?.label || 'Taxonomy' })] }) }), _jsx("div", { className: styles.detailContent, children: activeTaxonomyId === 'categories' ? (_jsx(CategoryManager, { categories: categories, pathValidation: pathValidation, onUpdateCategory: onUpdateCategory, onRemoveCategory: onRemoveCategory, onSaveCategory: onSaveCategory, onAddPath: onAddPath, onRemovePath: onRemovePath, onUpdateCategoryIcon: onUpdateCategoryIcon, onUpdateCategoryColor: onUpdateCategoryColor, onBrowseFolders: onBrowseFolders })) : activeTaxonomyId === 'types' ? (_jsx(TypeManager, { types: types, onSaveType: onSaveType, onRemoveType: onRemoveType })) : activeTaxonomyId === 'complexities' ? (_jsxs("div", { className: styles.settingGroup, children: [_jsx("h4", { className: styles.settingSubtitle, children: "Complexity" }), _jsx("p", { className: styles.settingsHint, children: "Complexity is estimated by AI and system logic by default." }), _jsx("p", { className: styles.settingsHint, children: "Enable this to let users set complexity manually and show the Complexity field in Add/Edit Task. When disabled, the Complexity field is hidden from the task form." }), _jsxs("label", { className: styles.archiveToggle, children: [_jsx("input", { type: "checkbox", checked: manualComplexityEnabled, onChange: (e) => {
+                                        void onManualComplexityEnabledChange(e.target.checked);
+                                    } }), _jsx("span", { children: "Manual Complexity" })] })] })) : activeTaxonomy ? (_jsx(TaxonomyEditor, { taxonomy: activeTaxonomy, onUpdateTaxonomy: handleUpdateTaxonomy, onRemoveTaxonomy: handleRemoveTaxonomy })) : activeTaxonomyId === 'priorities' ? (_jsx(TaxonomyEditor, { taxonomy: {
+                        id: 'priorities',
+                        label: 'Priority Levels',
+                        isSystem: true,
+                        widgetType: 'level',
+                        multiSelect: false,
+                        options: priorities
+                    }, onUpdateTaxonomy: (updated) => onUpdatePriorities(updated.options) })) : activeTaxonomyId === 'approaches' ? (_jsx(TaxonomyEditor, { taxonomy: {
+                        id: 'approaches',
+                        label: 'Approach Options',
+                        isSystem: true,
+                        widgetType: 'select',
+                        multiSelect: false,
+                        options: approaches
+                    }, onUpdateTaxonomy: (updated) => onUpdateApproaches(updated.options) })) : (_jsxs("div", { className: styles.emptyState, children: [_jsx("p", { children: "Taxonomy not found." }), _jsx("button", { className: styles.submitBtn, onClick: () => setView('list'), children: "Return to List" })] })) })] }));
+}

package/dist/components/features/settings/TypeManager.d.ts

@@ -0,0 +1,10 @@
+interface TypeManagerProps {
+    types: {
+        value: string;
+        label: string;
+    }[];
+    onSaveType: (label: string) => void;
+    onRemoveType: (value: string) => void;
+}
+export declare function TypeManager(props: TypeManagerProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Plus, X, Trash2 } from 'lucide-react';
+import styles from '../../../Taskforce.module.css';
+import { TaxonomyDropdown } from '../../ui/TaxonomyDropdown';
+import { TypeMeta } from '../../../utils/constants';
+export function TypeManager(props) {
+    const { types, onSaveType, onRemoveType } = props;
+    const [selectedTypeValue, setSelectedTypeValue] = useState('');
+    const [isCreating, setIsCreating] = useState(false);
+    const [newTypeLabel, setNewTypeLabel] = useState('');
+    const [editingLabel, setEditingLabel] = useState('');
+    // Sync editing label when selection changes
+    useEffect(() => {
+        const type = types.find(t => t.value === selectedTypeValue);
+        if (type) {
+            setEditingLabel(type.label);
+        }
+    }, [selectedTypeValue, types]);
+    const handleSaveNewType = () => {
+        if (!newTypeLabel.trim())
+            return;
+        onSaveType(newTypeLabel);
+        const predictedId = newTypeLabel.trim().toLowerCase().replace(/\s+/g, '-');
+        setNewTypeLabel('');
+        setIsCreating(false);
+        setTimeout(() => setSelectedTypeValue(predictedId), 100);
+    };
+    const selectedType = types.find(t => t.value === selectedTypeValue);
+    return (_jsxs("div", { className: `${styles.configPanel} ${styles.flex1}`, children: [_jsxs("div", { className: `${styles.headerFlex}`, style: { marginBottom: (selectedType && !isCreating) || isCreating ? '20px' : '0' }, children: [_jsxs("div", { style: { flex: 1 }, children: [_jsx("label", { id: "type-config-label", className: styles.label, style: { display: 'none' }, children: "Select Type" }), _jsx(TaxonomyDropdown, { value: selectedTypeValue, options: [
+                                    { value: "", label: "Select a type to configure...", icon: "HelpCircle", color: "var(--text-secondary)" },
+                                    ...types.map(t => ({
+                                        value: t.value,
+                                        label: t.label,
+                                        icon: TypeMeta[t.value]?.icon || 'Box',
+                                        color: TypeMeta[t.value]?.color || 'violet-500'
+                                    }))
+                                ], 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) => {
+                                    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: "Label" }), _jsxs("div", { className: styles.gridConfig, children: [_jsx("input", { className: styles.inputDisabledOpacity, value: editingLabel, readOnly: true, disabled: true }), _jsxs("button", { type: "button", onClick: () => {
+                                                if (confirm(`Delete type "${selectedType.label}"?`)) {
+                                                    onRemoveType(selectedType.value);
+                                                    setSelectedTypeValue('');
+                                                }
+                                            }, title: "Delete Type", className: `${styles.destructiveBtn} ${styles.deleteBtnMedium}`, children: [_jsx(Trash2, { size: 14, className: styles.trashIcon }), " Delete"] })] })] }) }), _jsx("p", { className: `${styles.settingsHint} ${styles.marginTop12}`, children: "Note: Renaming types is currently not supported to maintain task integrity. Delete and recreate if necessary." })] })), !selectedType && !isCreating && (_jsx("div", { className: styles.emptyStateItalic, style: { border: 'none', background: 'transparent' }, children: "Select a type above to manage" }))] }));
+}

package/dist/components/features/settings/WorkflowEditorPrototype.d.ts

@@ -0,0 +1,15 @@
+interface WorkflowEditorPrototypeProps {
+    availableWorkflows: string[];
+    onFetchWorkflowTemplate?: (name: string) => Promise<any | null>;
+    onFetchWorkflowOverrideNames?: () => Promise<string[]>;
+    onSaveWorkflowTemplateDraft?: (name: string, draft: any) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    onResetWorkflowTemplateDraft?: (name: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+export declare function WorkflowEditorPrototype(props: WorkflowEditorPrototypeProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,245 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { Copy, Loader2, RotateCcw } from 'lucide-react';
+import styles from '../../../Taskforce.module.css';
+const LOCKED_FIELDS_BY_WORKFLOW = {
+    do: ['aliasesText', 'dispatchDefault', 'criticalToolsText', 'contentDefault'],
+    execute: ['aliasesText', 'dispatchDefault', 'criticalToolsText', 'contentDefault']
+};
+const PREFERRED_WORKFLOW_ORDER = ['do', 'evaluate', 'collaborate', 'plan', 'review', 'execute'];
+function toDraft(template) {
+    return {
+        description: template.description || '',
+        aliasesText: (template.dispatch?.aliases || []).join(', '),
+        dispatchDefault: template.dispatch?.default || '',
+        criticalToolsText: (template.compat?.requiredToolsCritical || []).join('\n'),
+        optionalToolsText: (template.compat?.requiredToolsOptional || []).join('\n'),
+        contentDefault: template.content?.default || ''
+    };
+}
+function fromTextList(value) {
+    return value
+        .split(/\n|,/)
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+function toUniqueList(value) {
+    return Array.from(new Set(value.map((v) => v.trim()).filter(Boolean)));
+}
+export function WorkflowEditorPrototype(props) {
+    const { availableWorkflows, onFetchWorkflowTemplate, onFetchWorkflowOverrideNames, onSaveWorkflowTemplateDraft, onResetWorkflowTemplateDraft } = props;
+    const [selectedWorkflow, setSelectedWorkflow] = useState('');
+    const [loading, setLoading] = useState(false);
+    const [loadError, setLoadError] = useState(null);
+    const [template, setTemplate] = useState(null);
+    const [draft, setDraft] = useState(null);
+    const [saveState, setSaveState] = useState(null);
+    const [saving, setSaving] = useState(false);
+    const [resetting, setResetting] = useState(false);
+    const [overrideNames, setOverrideNames] = useState([]);
+    const [newAlias, setNewAlias] = useState('');
+    const [newCriticalTool, setNewCriticalTool] = useState('');
+    const [newOptionalTool, setNewOptionalTool] = useState('');
+    const orderedWorkflows = useMemo(() => {
+        const preferred = PREFERRED_WORKFLOW_ORDER.filter((name) => availableWorkflows.includes(name));
+        const remaining = availableWorkflows
+            .filter((name) => !PREFERRED_WORKFLOW_ORDER.includes(name))
+            .sort((a, b) => a.localeCompare(b));
+        return [...preferred, ...remaining];
+    }, [availableWorkflows]);
+    useEffect(() => {
+        if (!selectedWorkflow && orderedWorkflows.length > 0) {
+            setSelectedWorkflow(orderedWorkflows[0]);
+        }
+    }, [orderedWorkflows, selectedWorkflow]);
+    useEffect(() => {
+        let cancelled = false;
+        const loadOverrides = async () => {
+            if (!onFetchWorkflowOverrideNames)
+                return;
+            const names = await onFetchWorkflowOverrideNames();
+            if (cancelled)
+                return;
+            setOverrideNames(names);
+        };
+        loadOverrides();
+        return () => {
+            cancelled = true;
+        };
+    }, [onFetchWorkflowOverrideNames, availableWorkflows]);
+    useEffect(() => {
+        let cancelled = false;
+        const load = async () => {
+            if (!selectedWorkflow || !onFetchWorkflowTemplate)
+                return;
+            setLoading(true);
+            setLoadError(null);
+            const data = await onFetchWorkflowTemplate(selectedWorkflow);
+            if (cancelled)
+                return;
+            if (!data) {
+                setTemplate(null);
+                setDraft(null);
+                setLoadError('Unable to load workflow template. Reload Taskforce, and if needed restart the dev/server process.');
+                setLoading(false);
+                return;
+            }
+            const next = data;
+            setTemplate(next);
+            setDraft(toDraft(next));
+            setLoading(false);
+        };
+        load();
+        return () => {
+            cancelled = true;
+        };
+    }, [selectedWorkflow, onFetchWorkflowTemplate]);
+    const validation = useMemo(() => {
+        if (!draft)
+            return [];
+        const issues = [];
+        if (!draft.description.trim())
+            issues.push('Description is required.');
+        if (!draft.dispatchDefault.trim())
+            issues.push('Dispatch default is required.');
+        if (fromTextList(draft.criticalToolsText).length === 0)
+            issues.push('At least one critical tool is required.');
+        if (!draft.contentDefault.trim())
+            issues.push('Default content cannot be empty.');
+        return issues;
+    }, [draft]);
+    const lockedFields = useMemo(() => {
+        return LOCKED_FIELDS_BY_WORKFLOW[selectedWorkflow] || [];
+    }, [selectedWorkflow]);
+    const isLocked = (field) => lockedFields.includes(field);
+    const changedFields = useMemo(() => {
+        if (!template || !draft)
+            return [];
+        const baseline = toDraft(template);
+        const changes = [];
+        if (baseline.description !== draft.description)
+            changes.push('description');
+        if (baseline.aliasesText !== draft.aliasesText)
+            changes.push('aliases');
+        if (baseline.dispatchDefault !== draft.dispatchDefault)
+            changes.push('dispatch.default');
+        if (baseline.criticalToolsText !== draft.criticalToolsText)
+            changes.push('compat.requiredToolsCritical');
+        if (baseline.optionalToolsText !== draft.optionalToolsText)
+            changes.push('compat.requiredToolsOptional');
+        if (baseline.contentDefault !== draft.contentDefault)
+            changes.push('content.default');
+        return changes;
+    }, [template, draft]);
+    const preview = useMemo(() => {
+        if (!template || !draft)
+            return '';
+        return [
+            `# ${template.name} (Prototype Preview)`,
+            '',
+            `Description: ${draft.description}`,
+            `Aliases: ${draft.aliasesText || '(none)'}`,
+            `Dispatch default: ${draft.dispatchDefault || '(none)'}`,
+            '',
+            '## Critical Tools',
+            ...fromTextList(draft.criticalToolsText).map((t) => `- ${t}`),
+            '',
+            '## Optional Tools',
+            ...fromTextList(draft.optionalToolsText).map((t) => `- ${t}`),
+            '',
+            '## Prompt Content Preview',
+            draft.contentDefault
+        ].join('\n');
+    }, [template, draft]);
+    const baselineDraft = useMemo(() => (template ? toDraft(template) : null), [template]);
+    const diffRows = useMemo(() => {
+        if (!baselineDraft || !draft)
+            return [];
+        const rows = [];
+        const pushIfChanged = (field, before, after) => {
+            if (before !== after)
+                rows.push({ field, before, after });
+        };
+        pushIfChanged('description', baselineDraft.description, draft.description);
+        pushIfChanged('aliases', baselineDraft.aliasesText, draft.aliasesText);
+        pushIfChanged('dispatch.default', baselineDraft.dispatchDefault, draft.dispatchDefault);
+        pushIfChanged('compat.requiredToolsCritical', baselineDraft.criticalToolsText, draft.criticalToolsText);
+        pushIfChanged('compat.requiredToolsOptional', baselineDraft.optionalToolsText, draft.optionalToolsText);
+        pushIfChanged('content.default', baselineDraft.contentDefault, draft.contentDefault);
+        return rows;
+    }, [baselineDraft, draft]);
+    const handleResetDraft = () => {
+        if (!template)
+            return;
+        setDraft(toDraft(template));
+    };
+    const handleCopyPreview = async () => {
+        if (!preview)
+            return;
+        await navigator.clipboard.writeText(preview);
+    };
+    const handleSaveDraft = async () => {
+        if (!selectedWorkflow || !draft || validation.length > 0 || !onSaveWorkflowTemplateDraft)
+            return;
+        setSaving(true);
+        setSaveState(null);
+        const result = await onSaveWorkflowTemplateDraft(selectedWorkflow, draft);
+        if (!result.success) {
+            setSaveState({ type: 'error', message: result.error || 'Failed to save workflow draft.' });
+            setSaving(false);
+            return;
+        }
+        const refreshed = onFetchWorkflowTemplate ? await onFetchWorkflowTemplate(selectedWorkflow) : null;
+        if (refreshed) {
+            setTemplate(refreshed);
+            setDraft(toDraft(refreshed));
+        }
+        setSaveState({ type: 'success', message: 'Workflow draft saved and templates regenerated.' });
+        if (onFetchWorkflowOverrideNames) {
+            const names = await onFetchWorkflowOverrideNames();
+            setOverrideNames(names);
+        }
+        setSaving(false);
+    };
+    const handleRollback = async () => {
+        if (!selectedWorkflow || !onResetWorkflowTemplateDraft)
+            return;
+        setResetting(true);
+        setSaveState(null);
+        const result = await onResetWorkflowTemplateDraft(selectedWorkflow);
+        if (!result.success) {
+            setSaveState({ type: 'error', message: result.error || 'Failed to reset workflow override.' });
+            setResetting(false);
+            return;
+        }
+        const refreshed = onFetchWorkflowTemplate ? await onFetchWorkflowTemplate(selectedWorkflow) : null;
+        if (refreshed) {
+            setTemplate(refreshed);
+            setDraft(toDraft(refreshed));
+        }
+        setSaveState({ type: 'success', message: 'Workflow override reset and templates regenerated.' });
+        if (onFetchWorkflowOverrideNames) {
+            const names = await onFetchWorkflowOverrideNames();
+            setOverrideNames(names);
+        }
+        setResetting(false);
+    };
+    const updateListField = (field, nextList) => {
+        if (!draft)
+            return;
+        const value = toUniqueList(nextList).join('\n');
+        setDraft({ ...draft, [field]: value });
+    };
+    const removeListItem = (field, item) => {
+        const current = fromTextList(draft?.[field] || '');
+        updateListField(field, current.filter((v) => v !== item));
+    };
+    const addListItem = (field, item, clear) => {
+        if (!draft || !item.trim())
+            return;
+        const current = fromTextList(draft[field] || '');
+        updateListField(field, [...current, item]);
+        clear();
+    };
+    return (_jsxs("div", { className: styles.settingGroup, children: [_jsx("h3", { className: styles.settingTitle, children: "Workflow Editor (Prototype)" }), _jsx("p", { className: styles.settingsHint, children: "Prototype editor: inspect workflow structure, edit a draft, validate, preview, and save via override layer. Critical fields are locked for `do` and `execute`." }), _jsxs("div", { className: styles.pathInputGroup, children: [_jsx("label", { className: styles.label, htmlFor: "workflow-editor-select", children: "Workflow" }), _jsx("select", { id: "workflow-editor-select", className: styles.input, value: selectedWorkflow, onChange: (e) => setSelectedWorkflow(e.target.value), children: orderedWorkflows.map((wf) => (_jsx("option", { value: wf, children: overrideNames.includes(wf) ? `${wf} (override)` : wf }, wf))) })] }), loading && (_jsxs("div", { className: styles.settingsHint, children: [_jsx(Loader2, { size: 14, className: styles.spinner }), " Loading template..."] })), loadError && _jsx("div", { className: styles.errorMessage, children: loadError }), draft && (_jsxs(_Fragment, { children: [_jsxs("div", { className: `${styles.exportRow} ${styles.exportRowGrid}`, style: { marginTop: 12 }, children: [_jsxs("div", { className: styles.exportItem, children: [_jsx("label", { className: styles.label, children: "Description" }), _jsx("input", { className: styles.input, value: draft.description, onChange: (e) => setDraft({ ...draft, description: e.target.value }), disabled: isLocked('description') }), _jsx("label", { className: styles.label, children: "Aliases (comma-separated)" }), _jsxs("div", { className: styles.pathInputGroup, children: [_jsx("input", { className: styles.input, value: newAlias, onChange: (e) => setNewAlias(e.target.value), placeholder: "Add alias (e.g. /execute)", disabled: isLocked('aliasesText') }), _jsx("button", { className: styles.secondaryHeaderBtn, onClick: () => addListItem('aliasesText', newAlias, () => setNewAlias('')), disabled: isLocked('aliasesText') || !newAlias.trim(), children: "Add" })] }), _jsx("div", { className: styles.workflowActions, children: fromTextList(draft.aliasesText).map((alias) => (_jsxs("button", { className: styles.textBtn, onClick: () => removeListItem('aliasesText', alias), disabled: isLocked('aliasesText'), children: [alias, " \u00D7"] }, alias))) }), _jsx("label", { className: styles.label, children: "Dispatch Default" }), _jsx("input", { className: styles.input, value: draft.dispatchDefault, onChange: (e) => setDraft({ ...draft, dispatchDefault: e.target.value }), disabled: isLocked('dispatchDefault') })] }), _jsxs("div", { className: styles.exportItem, children: [_jsx("label", { className: styles.label, children: "Critical Tools (one per line)" }), _jsxs("div", { className: styles.pathInputGroup, children: [_jsx("input", { className: styles.input, value: newCriticalTool, onChange: (e) => setNewCriticalTool(e.target.value), placeholder: "Add critical tool id", disabled: isLocked('criticalToolsText') }), _jsx("button", { className: styles.secondaryHeaderBtn, onClick: () => addListItem('criticalToolsText', newCriticalTool, () => setNewCriticalTool('')), disabled: isLocked('criticalToolsText') || !newCriticalTool.trim(), children: "Add" })] }), _jsx("div", { className: styles.workflowActions, children: fromTextList(draft.criticalToolsText).map((tool) => (_jsxs("button", { className: styles.textBtn, onClick: () => removeListItem('criticalToolsText', tool), disabled: isLocked('criticalToolsText'), children: [tool, " \u00D7"] }, tool))) }), _jsx("label", { className: styles.label, children: "Optional Tools (one per line)" }), _jsxs("div", { className: styles.pathInputGroup, children: [_jsx("input", { className: styles.input, value: newOptionalTool, onChange: (e) => setNewOptionalTool(e.target.value), placeholder: "Add optional tool id", disabled: isLocked('optionalToolsText') }), _jsx("button", { className: styles.secondaryHeaderBtn, onClick: () => addListItem('optionalToolsText', newOptionalTool, () => setNewOptionalTool('')), disabled: isLocked('optionalToolsText') || !newOptionalTool.trim(), children: "Add" })] }), _jsx("div", { className: styles.workflowActions, children: fromTextList(draft.optionalToolsText).map((tool) => (_jsxs("button", { className: styles.textBtn, onClick: () => removeListItem('optionalToolsText', tool), disabled: isLocked('optionalToolsText'), children: [tool, " \u00D7"] }, tool))) })] })] }), _jsx("label", { className: styles.label, children: "Default Prompt Content" }), _jsx("textarea", { className: styles.input, rows: 12, value: draft.contentDefault, onChange: (e) => setDraft({ ...draft, contentDefault: e.target.value }), disabled: isLocked('contentDefault') }), _jsxs("div", { className: styles.pathInputGroup, style: { marginTop: 12 }, children: [_jsxs("button", { className: styles.secondaryHeaderBtn, onClick: handleResetDraft, children: [_jsx(RotateCcw, { size: 14 }), "Reset Draft"] }), _jsxs("button", { className: styles.secondaryHeaderBtn, onClick: handleCopyPreview, children: [_jsx(Copy, { size: 14 }), "Copy Preview"] }), _jsxs("button", { className: styles.secondaryHeaderBtn, onClick: handleSaveDraft, disabled: saving || validation.length > 0 || changedFields.length === 0, children: [saving ? _jsx(Loader2, { size: 14, className: styles.spinner }) : null, "Save Draft"] }), _jsxs("button", { className: styles.secondaryHeaderBtn, onClick: handleRollback, disabled: resetting, children: [resetting ? _jsx(Loader2, { size: 14, className: styles.spinner }) : null, "Rollback Override"] })] }), changedFields.length > 0 && (_jsxs("div", { className: styles.settingsHint, children: ["Changed fields: ", changedFields.join(', ')] })), lockedFields.length > 0 && (_jsxs("div", { className: styles.settingsHint, children: ["Locked fields for `", selectedWorkflow, "`: ", lockedFields.join(', ')] })), validation.length === 0 ? (_jsx("div", { className: styles.successMessage, children: "Draft validation: ready for prototype review." })) : (_jsx("div", { className: styles.errorMessage, children: validation.map((issue) => _jsx("div", { children: issue }, issue)) })), saveState && (_jsx("div", { className: saveState.type === 'success' ? styles.successMessage : styles.errorMessage, children: saveState.message })), diffRows.length > 0 && (_jsxs("div", { className: styles.codeBlockWrapper, style: { marginTop: 12 }, children: [_jsx("div", { className: styles.codeHeader, children: _jsx("span", { className: styles.codeLabel, children: "Field Diff (Before / After)" }) }), diffRows.map((row) => (_jsxs("div", { style: { marginBottom: 12 }, children: [_jsx("div", { className: styles.settingsHint, children: _jsx("strong", { children: row.field }) }), _jsxs("div", { className: `${styles.exportRow} ${styles.exportRowGrid}`, children: [_jsxs("div", { className: styles.exportItem, children: [_jsx("div", { className: styles.settingsHint, children: "Before" }), _jsx("pre", { className: styles.codeBlock, children: row.before || '(empty)' })] }), _jsxs("div", { className: styles.exportItem, children: [_jsx("div", { className: styles.settingsHint, children: "After" }), _jsx("pre", { className: styles.codeBlock, children: row.after || '(empty)' })] })] })] }, row.field)))] })), _jsxs("div", { className: styles.codeBlockWrapper, style: { marginTop: 12 }, children: [_jsx("div", { className: styles.codeHeader, children: _jsx("span", { className: styles.codeLabel, children: "Prototype Preview" }) }), _jsx("pre", { className: styles.codeBlock, children: preview })] })] }))] }));
+}

package/dist/components/task/TaskActionHeader.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { TaskItem } from '../../types';
+interface TaskActionHeaderProps {
+    editingTaskId: string | null;
+    loading: boolean;
+    title: string;
+    handleSubmit: (e: React.FormEvent | React.MouseEvent) => void;
+    resetForm: () => void;
+    handleCopyId: (e: React.MouseEvent, id: string) => void;
+    copiedId: string | null;
+    tasks: TaskItem[];
+    currentTask?: TaskItem;
+    handleToggleInProgress: (task: TaskItem) => void;
+    handleToggleReview: (task: TaskItem) => void;
+    handleToggleComplete: (task: TaskItem) => void;
+    handleToggleCancel: (task: TaskItem) => void;
+    handleArchiveTask: (task: TaskItem) => void;
+}
+export declare function TaskActionHeader({ editingTaskId, loading, title, handleSubmit, resetForm, handleCopyId, copiedId, tasks, currentTask: currentTaskProp, handleToggleInProgress, handleToggleReview, handleToggleComplete, handleToggleCancel, handleArchiveTask }: TaskActionHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/task/TaskActionHeader.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Save, Loader2, Copy, Play, Pause, Sparkles, Check, Ban, Archive, RotateCcw, Plus } from 'lucide-react';
+import styles from '../../Taskforce.module.css';
+import { t } from '../../localization';
+export function TaskActionHeader({ editingTaskId, loading, title, handleSubmit, resetForm, handleCopyId, copiedId, tasks, currentTask: currentTaskProp, handleToggleInProgress, handleToggleReview, handleToggleComplete, handleToggleCancel, handleArchiveTask }) {
+    const currentTask = currentTaskProp ?? (editingTaskId ? tasks.find(t => t.id === editingTaskId) || null : null);
+    const isArchivedReadOnly = Boolean(currentTask?.isArchived);
+    return (_jsx("div", { className: styles.stickyActionHeader, children: editingTaskId ? (_jsxs(_Fragment, { children: [_jsxs("button", { type: "button", onClick: (e) => handleSubmit(e), disabled: loading || !title.trim() || isArchivedReadOnly, className: styles.primaryUpdateBtn, title: isArchivedReadOnly ? 'Archived tasks are read-only. Unarchive first.' : t('actionHeader.saveChangesTitle'), children: [loading ? _jsx(Loader2, { size: 16, className: styles.spinner }) : _jsx(Save, { size: 16 }), t('actionHeader.update')] }), _jsxs("button", { className: `${styles.taskIdBadgeStatic} ${copiedId === editingTaskId ? styles.copiedId : ''}`, onClick: (e) => handleCopyId(e, editingTaskId), disabled: loading, title: t('actionHeader.copyTaskIdTitle'), children: [copiedId === editingTaskId ? _jsx(Check, { size: 13 }) : _jsx(Copy, { size: 13 }), _jsxs("span", { children: ["ID: ", editingTaskId.split('-').slice(-1)[0]] })] }), _jsxs("div", { className: styles.editActionsGroup, children: [_jsx("button", { type: "button", className: `${styles.actionBtn} ${currentTask?.status === 'in-progress' ? styles.workingBtn : styles.startWorkBtn}`, disabled: loading || !currentTask || isArchivedReadOnly, onClick: () => currentTask && handleToggleInProgress(currentTask), title: currentTask?.status === 'in-progress' ? t('actionHeader.stopWorking') : t('actionHeader.startWorking'), children: currentTask?.status === 'in-progress' ? _jsx(Pause, { size: 18 }) : _jsx(Play, { size: 18 }) }), _jsx("button", { type: "button", className: `${styles.actionBtn} ${currentTask?.status === 'review' ? styles.reviewActiveBtn : styles.reviewBtn}`, disabled: loading || !currentTask || isArchivedReadOnly, onClick: () => currentTask && handleToggleReview(currentTask), title: currentTask?.status === 'review' ? t('actionHeader.unlockAndContinue') : t('actionHeader.readyForReview'), children: _jsx(Sparkles, { size: 18 }) }), _jsx("button", { type: "button", className: `${styles.actionBtn} ${currentTask?.status === 'done' ? styles.completeActiveBtn : styles.completeBtn}`, disabled: loading || !currentTask || isArchivedReadOnly, onClick: () => currentTask && handleToggleComplete(currentTask), title: currentTask?.status === 'done' ? t('actionHeader.unmarkComplete') : t('actionHeader.markComplete'), children: _jsx(Check, { size: 18 }) }), _jsx("button", { type: "button", className: `${styles.actionBtn} ${currentTask?.status === 'cancelled' ? styles.deleteActiveBtn : styles.deleteBtn}`, disabled: loading || !currentTask || isArchivedReadOnly, onClick: () => currentTask && handleToggleCancel(currentTask), title: currentTask?.status === 'cancelled' ? t('actionHeader.unmarkCancelled') : t('actionHeader.cancelTask'), children: _jsx(Ban, { size: 18 }) }), _jsx("button", { type: "button", className: `${styles.actionBtn} ${styles.archiveTaskBtn} ${!(currentTask?.status === 'done' || currentTask?.status === 'cancelled') ? styles.disabledBtn : ''}`, onClick: () => {
+                                if (currentTask && (currentTask.status === 'done' || currentTask.status === 'cancelled')) {
+                                    handleArchiveTask(currentTask);
+                                }
+                            }, disabled: loading || isArchivedReadOnly || !(currentTask?.status === 'done' || currentTask?.status === 'cancelled'), title: currentTask?.status === 'done' || currentTask?.status === 'cancelled' ? t('actionHeader.archiveNow') : t('actionHeader.completeTaskToArchive'), children: _jsx(Archive, { size: 18 }) })] })] })) : (_jsxs(_Fragment, { children: [_jsxs("button", { type: "button", onClick: resetForm, disabled: loading, className: styles.secondaryHeaderBtn, title: t('actionHeader.clearFormTitle'), children: [_jsx(RotateCcw, { size: 16 }), t('actionHeader.clear')] }), _jsxs("button", { type: "button", onClick: (e) => handleSubmit(e), disabled: loading || !title.trim(), className: styles.primaryUpdateBtn, title: t('actionHeader.addTaskTitle'), children: [loading ? _jsx(Loader2, { size: 16, className: styles.spinner }) : _jsx(Plus, { size: 16 }), t('actionHeader.addTask')] })] })) }));
+}