@taskforcehq/taskforce 0.3.168

package/dist/components/features/DocumentViewer.js

@@ -0,0 +1,253 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from 'react';
+import Markdown from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+import rehypeSanitize from 'rehype-sanitize';
+import { Printer, Link, Download, Clock, HardDrive, Tag, Pencil, X, Save, Eye, SplitSquareHorizontal, CheckCircle, AlertCircle, Zap } from 'lucide-react';
+import styles from '../../Taskforce.module.css';
+import { DocumentGenerateModal } from './DocumentGenerateModal';
+import { fetchTaskforceApi, resolveTaskforceApiUrl } from '../../utils/taskforceApiClient';
+const DOC_TYPE_LABELS = {
+    'implementation-plan': 'Implementation Plan',
+    'review': 'Review',
+    'walkthrough': 'Walkthrough',
+    'planning': 'Planning',
+    'other': 'Document',
+};
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDate(iso) {
+    if (!iso)
+        return '—';
+    return new Date(iso).toLocaleString();
+}
+function toggleNthTaskCheckbox(markdown, targetIndex, nextChecked) {
+    if (targetIndex < 0)
+        return markdown;
+    const lines = markdown.split('\n');
+    let seen = -1;
+    const taskLinePattern = /^(\s*(?:[-*+]|\d+\.)\s+)\[( |x|X)\](.*)$/;
+    const replacementMark = nextChecked ? 'x' : ' ';
+    const updated = lines.map((line) => {
+        const match = line.match(taskLinePattern);
+        if (!match)
+            return line;
+        seen += 1;
+        if (seen !== targetIndex)
+            return line;
+        return `${match[1]}[${replacementMark}]${match[3]}`;
+    });
+    return updated.join('\n');
+}
+export function DocumentViewer({ doc, taskTitle, apiBaseUrl = '', onSaved }) {
+    const [content, setContent] = useState(null);
+    const [loadingContent, setLoadingContent] = useState(false);
+    const [loadError, setLoadError] = useState(null);
+    const [copied, setCopied] = useState(false);
+    // Edit mode state
+    const [editMode, setEditMode] = useState(false);
+    const [draft, setDraft] = useState('');
+    const [layout, setLayout] = useState('split');
+    const [saveStatus, setSaveStatus] = useState({ type: 'idle' });
+    const [showGenModal, setShowGenModal] = useState(false);
+    const [monochromeMode, setMonochromeMode] = useState(false);
+    const isDirty = editMode && draft !== (content ?? '');
+    const textareaRef = useRef(null);
+    const fetchContent = useCallback(async () => {
+        setLoadingContent(true);
+        setLoadError(null);
+        setContent(null);
+        try {
+            const path = `/api/taskforce/context-link?path=${encodeURIComponent(doc.fsPath)}`;
+            const res = await fetchTaskforceApi(path, { credentials: 'include' }, apiBaseUrl);
+            if (!res.ok)
+                throw new Error(`Failed to load document (${res.status})`);
+            const text = await res.text();
+            setContent(text);
+            setDraft(text);
+        }
+        catch (e) {
+            setLoadError(e?.message || 'Failed to load document');
+        }
+        finally {
+            setLoadingContent(false);
+        }
+    }, [doc.fsPath, apiBaseUrl]);
+    useEffect(() => {
+        fetchContent();
+        // Reset edit mode when doc changes
+        setEditMode(false);
+        setSaveStatus({ type: 'idle' });
+    }, [fetchContent]);
+    // Ctrl+S / Cmd+S to save while editing
+    useEffect(() => {
+        if (!editMode)
+            return;
+        const handler = (e) => {
+            if ((e.metaKey || e.ctrlKey) && e.key === 's') {
+                e.preventDefault();
+                handleSave();
+            }
+        };
+        window.addEventListener('keydown', handler);
+        return () => window.removeEventListener('keydown', handler);
+    }, [editMode, draft]); // eslint-disable-line react-hooks/exhaustive-deps
+    const handleEnterEdit = () => {
+        setDraft(content ?? '');
+        setSaveStatus({ type: 'idle' });
+        setEditMode(true);
+        // Focus textarea on next frame
+        setTimeout(() => textareaRef.current?.focus(), 50);
+    };
+    const handleCancelEdit = () => {
+        if (isDirty) {
+            if (!window.confirm('Discard unsaved changes?'))
+                return;
+        }
+        setEditMode(false);
+        setDraft(content ?? '');
+        setSaveStatus({ type: 'idle' });
+    };
+    const handleSave = useCallback(async () => {
+        if (saveStatus.type === 'saving')
+            return;
+        setSaveStatus({ type: 'saving' });
+        try {
+            const res = await fetchTaskforceApi('/api/taskforce/documents/save', {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ fsPath: doc.fsPath, content: draft }),
+            }, apiBaseUrl);
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok)
+                throw new Error(data.error || `Save failed (${res.status})`);
+            const updatedAt = data.updatedAt || new Date().toISOString();
+            setContent(draft);
+            setSaveStatus({ type: 'saved', savedAt: updatedAt });
+            onSaved?.(updatedAt);
+            // Return to view mode
+            setEditMode(false);
+        }
+        catch (e) {
+            setSaveStatus({ type: 'error', message: e?.message || 'Save failed' });
+        }
+    }, [apiBaseUrl, doc.fsPath, draft, saveStatus.type, onSaved]);
+    const handlePrint = () => window.print();
+    const handleCopyLink = async () => {
+        const path = `/api/taskforce/context-link?path=${encodeURIComponent(doc.fsPath)}`;
+        const url = new URL(resolveTaskforceApiUrl(path, apiBaseUrl), window.location.origin).toString();
+        try {
+            await navigator.clipboard.writeText(url);
+        }
+        catch {
+            const el = document.createElement('textarea');
+            el.value = url;
+            document.body.appendChild(el);
+            el.select();
+            document.execCommand('copy');
+            document.body.removeChild(el);
+        }
+        setCopied(true);
+        setTimeout(() => setCopied(false), 2000);
+    };
+    const handleDownload = () => {
+        const blob = new Blob([editMode ? draft : (content ?? '')], { type: 'text/markdown' });
+        const a = document.createElement('a');
+        a.href = URL.createObjectURL(blob);
+        a.download = doc.title + '.md';
+        a.click();
+        URL.revokeObjectURL(a.href);
+    };
+    const persistContent = useCallback(async (nextContent) => {
+        setSaveStatus({ type: 'saving' });
+        try {
+            const res = await fetchTaskforceApi('/api/taskforce/documents/save', {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ fsPath: doc.fsPath, content: nextContent }),
+            }, apiBaseUrl);
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok)
+                throw new Error(data.error || `Save failed (${res.status})`);
+            const updatedAt = data.updatedAt || new Date().toISOString();
+            setContent(nextContent);
+            setDraft(nextContent);
+            setSaveStatus({ type: 'saved', savedAt: updatedAt });
+            onSaved?.(updatedAt);
+            return true;
+        }
+        catch (e) {
+            setSaveStatus({ type: 'error', message: e?.message || 'Save failed' });
+            return false;
+        }
+    }, [apiBaseUrl, doc.fsPath, onSaved]);
+    const handleToggleTaskCheckbox = useCallback((checkboxIndex, nextChecked) => {
+        const currentSource = editMode ? draft : (content ?? '');
+        const nextSource = toggleNthTaskCheckbox(currentSource, checkboxIndex, nextChecked);
+        if (nextSource === currentSource)
+            return;
+        if (editMode) {
+            setDraft(nextSource);
+            setSaveStatus(prev => prev.type === 'saving' ? prev : { type: 'idle' });
+            return;
+        }
+        void persistContent(nextSource);
+    }, [content, draft, editMode, persistContent]);
+    const previewContent = editMode ? draft : (content ?? '');
+    let checkboxRenderIndex = -1;
+    const nodeHasCheckboxInput = (node) => {
+        if (!node || !Array.isArray(node.children))
+            return false;
+        return node.children.some((child) => {
+            if (!child)
+                return false;
+            if (child.type === 'element' &&
+                child.tagName === 'input' &&
+                child.properties?.type === 'checkbox') {
+                return true;
+            }
+            return nodeHasCheckboxInput(child);
+        });
+    };
+    const nodeHasTaskItems = (node) => {
+        if (!node || !Array.isArray(node.children))
+            return false;
+        return node.children.some((child) => {
+            if (typeof child?.checked === 'boolean')
+                return true;
+            return nodeHasCheckboxInput(child);
+        });
+    };
+    const markdownComponents = {
+        input({ type, checked, ...props }) {
+            if (type !== 'checkbox')
+                return _jsx("input", { type: type, checked: checked, ...props });
+            checkboxRenderIndex += 1;
+            const index = checkboxRenderIndex;
+            return (_jsx("input", { ...props, type: "checkbox", checked: Boolean(checked), disabled: false, onClick: (event) => event.stopPropagation(), onChange: (event) => handleToggleTaskCheckbox(index, event.currentTarget.checked) }));
+        },
+        ul({ children, node, ...props }) {
+            const taskList = nodeHasTaskItems(node);
+            return (_jsx("ul", { ...props, style: taskList ? { paddingLeft: '1.25em' } : undefined, "data-task-list": taskList ? 'true' : undefined, children: children }));
+        },
+        ol({ children, node, ...props }) {
+            const taskList = nodeHasTaskItems(node);
+            return (_jsx("ol", { ...props, style: taskList ? { paddingLeft: '1.25em' } : undefined, "data-task-list": taskList ? 'true' : undefined, children: children }));
+        },
+        li({ children, node, ...props }) {
+            const taskItem = typeof node?.checked === 'boolean' || nodeHasCheckboxInput(node);
+            return (_jsx("li", { ...props, style: taskItem ? { listStyleType: 'none', listStyle: 'none', marginLeft: 0 } : undefined, "data-task-item": taskItem ? 'true' : undefined, children: children }));
+        }
+    };
+    return (_jsxs("div", { className: `${styles.docViewer} ${editMode ? styles.docViewerEditMode : ''} ${monochromeMode ? styles.docViewerMonochrome : ''}`, children: [_jsxs("div", { className: styles.docMeta, children: [_jsxs("div", { className: styles.docMetaLeft, children: [_jsxs("span", { className: `${styles.docTypeBadge} ${styles[`docTypeBadge_${doc.docType.replace('-', '_')}`]}`, children: [_jsx(Tag, { size: 10 }), DOC_TYPE_LABELS[doc.docType]] }), taskTitle && (_jsx("span", { className: styles.docMetaTaskName, title: `From task: ${taskTitle}`, children: taskTitle })), doc.updatedAt && (_jsxs("span", { className: styles.docMetaDate, title: formatDate(doc.updatedAt), children: [_jsx(Clock, { size: 11 }), formatDate(doc.updatedAt)] })), _jsxs("span", { className: styles.docMetaSize, children: [_jsx(HardDrive, { size: 11 }), formatBytes(doc.sizeBytes)] }), saveStatus.type === 'saved' && (_jsxs("span", { className: styles.docSaveStatus, "data-status": "saved", children: [_jsx(CheckCircle, { size: 11 }), "Saved"] })), saveStatus.type === 'error' && (_jsxs("span", { className: styles.docSaveStatus, "data-status": "error", title: saveStatus.message, children: [_jsx(AlertCircle, { size: 11 }), saveStatus.message || 'Save failed'] })), isDirty && saveStatus.type !== 'saving' && (_jsx("span", { className: styles.docUnsaved, children: "Unsaved changes" }))] }), _jsx("div", { className: styles.docActions, children: editMode ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: styles.docLayoutToggle, children: [_jsx("button", { className: `${styles.docLayoutBtn} ${layout === 'editor' ? styles.docLayoutBtnActive : ''}`, onClick: () => setLayout('editor'), title: "Editor only", children: _jsx(Pencil, { size: 12 }) }), _jsx("button", { className: `${styles.docLayoutBtn} ${layout === 'split' ? styles.docLayoutBtnActive : ''}`, onClick: () => setLayout('split'), title: "Split view", children: _jsx(SplitSquareHorizontal, { size: 12 }) }), _jsx("button", { className: `${styles.docLayoutBtn} ${layout === 'preview' ? styles.docLayoutBtnActive : ''}`, onClick: () => setLayout('preview'), title: "Preview only", children: _jsx(Eye, { size: 12 }) })] }), _jsxs("button", { className: styles.docActionBtn, onClick: handleCancelEdit, title: "Discard changes", children: [_jsx(X, { size: 13 }), "Cancel"] }), _jsxs("button", { className: `${styles.docActionBtn} ${styles.docSaveBtn}`, onClick: handleSave, disabled: saveStatus.type === 'saving' || !isDirty, title: "Save (Ctrl+S)", children: [_jsx(Save, { size: 13 }), saveStatus.type === 'saving' ? 'Saving…' : 'Save'] })] })) : (_jsxs(_Fragment, { children: [_jsxs("button", { className: `${styles.docActionBtn} ${styles.docEditBtn}`, onClick: handleEnterEdit, title: "Edit document", children: [_jsx(Pencil, { size: 13 }), "Edit"] }), _jsxs("button", { className: styles.docActionBtn, onClick: handleCopyLink, title: "Copy link", children: [_jsx(Link, { size: 13 }), copied ? 'Copied!' : 'Copy link'] }), _jsxs("button", { className: styles.docActionBtn, onClick: handleDownload, title: "Download .md", children: [_jsx(Download, { size: 13 }), "Download"] }), _jsxs("button", { className: styles.docActionBtn, onClick: handlePrint, title: "Print", children: [_jsx(Printer, { size: 13 }), "Print"] }), _jsxs("button", { className: styles.docActionBtn, onClick: () => setMonochromeMode((prev) => !prev), title: "Toggle black and white style", children: [_jsx(Eye, { size: 13 }), monochromeMode ? 'Color' : 'B/W'] }), doc.docType === 'implementation-plan' && !editMode && (_jsxs("button", { className: `${styles.docActionBtn} ${styles.docGenerateBtn}`, onClick: () => setShowGenModal(true), title: "Generate tasks from this plan", children: [_jsx(Zap, { size: 13 }), "Generate Tasks"] }))] })) })] }), !editMode && (_jsx("div", { className: styles.docViewerTitleRow, children: _jsx("h1", { className: styles.docViewerTitle, children: doc.title }) })), loadingContent && (_jsx("div", { className: styles.docViewerState, children: "Loading\u2026" })), !loadingContent && loadError && (_jsx("div", { className: styles.docViewerStateError, children: loadError })), !loadingContent && !loadError && (editMode ? (_jsxs("div", { className: `${styles.docEditorArea} ${styles[`docEditorLayout_${layout}`]}`, children: [(layout === 'editor' || layout === 'split') && (_jsxs("div", { className: styles.docEditorPane, children: [_jsx("div", { className: styles.docEditorPaneLabel, children: "Markdown" }), _jsx("textarea", { ref: textareaRef, className: styles.docEditorTextarea, value: draft, onChange: e => {
+                                    setDraft(e.target.value);
+                                    setSaveStatus(prev => prev.type === 'saving' ? prev : { type: 'idle' });
+                                }, spellCheck: true, placeholder: "Write markdown here\u2026" })] })), (layout === 'preview' || layout === 'split') && (_jsxs("div", { className: styles.docPreviewPane, children: [_jsx("div", { className: styles.docEditorPaneLabel, children: "Preview" }), _jsx("div", { className: styles.docMarkdown, children: _jsx(Markdown, { remarkPlugins: [remarkGfm], rehypePlugins: [rehypeSanitize], components: markdownComponents, children: previewContent }) })] }))] })) : (_jsx("div", { className: styles.docViewerContent, children: _jsx("div", { className: styles.docMarkdown, children: _jsx(Markdown, { remarkPlugins: [remarkGfm], rehypePlugins: [rehypeSanitize], components: markdownComponents, children: previewContent }) }) }))), showGenModal && content !== null && (_jsx(DocumentGenerateModal, { content: content, docTitle: doc.title, apiBaseUrl: apiBaseUrl, onClose: () => setShowGenModal(false), onGenerated: (_count) => setShowGenModal(false) }))] }));
+}

package/dist/components/features/DocumentWorkspace.d.ts

@@ -0,0 +1,21 @@
+export interface DocMeta {
+    id: string;
+    fsPath: string;
+    apiUrl: string;
+    taskId: string | null;
+    title: string;
+    docType: 'implementation-plan' | 'review' | 'walkthrough' | 'planning' | 'other';
+    sizeBytes: number;
+    updatedAt: string | null;
+}
+interface Props {
+    tasks: Array<{
+        id: string;
+        title: string;
+    }>;
+    apiBaseUrl?: string;
+    requestedDocPath?: string | null;
+    onRequestedDocHandled?: () => void;
+}
+export declare function DocumentWorkspace({ tasks, apiBaseUrl, requestedDocPath, onRequestedDocHandled }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/features/DocumentWorkspace.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useCallback } from 'react';
+import styles from '../../Taskforce.module.css';
+import { DocumentIndex } from './DocumentIndex';
+import { DocumentViewer } from './DocumentViewer';
+import { fetchTaskforceApi } from '../../utils/taskforceApiClient';
+function normalizeDocPath(value) {
+    let decoded = value;
+    try {
+        decoded = decodeURIComponent(value);
+    }
+    catch {
+        decoded = value;
+    }
+    const normalized = decoded
+        .trim()
+        .replace(/\\/g, '/')
+        .replace(/^\/+/, '')
+        .replace(/^\.\//, '')
+        .replace(/^\.taskforce\//, '');
+    return normalized;
+}
+function docPathMatches(candidate, requested) {
+    if (candidate === requested)
+        return true;
+    if (candidate.endsWith(`/${requested}`))
+        return true;
+    if (requested.endsWith(`/${candidate}`))
+        return true;
+    return false;
+}
+export function DocumentWorkspace({ tasks, apiBaseUrl = '', requestedDocPath = null, onRequestedDocHandled }) {
+    const [documents, setDocuments] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [selectedDoc, setSelectedDoc] = useState(null);
+    const [searchQuery, setSearchQuery] = useState('');
+    const [typeFilter, setTypeFilter] = useState('all');
+    const fetchDocuments = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const res = await fetchTaskforceApi('/api/taskforce/documents', {
+                credentials: 'include',
+            }, apiBaseUrl);
+            if (!res.ok)
+                throw new Error(`Failed to load documents (${res.status})`);
+            const data = await res.json();
+            setDocuments(data.documents || []);
+        }
+        catch (e) {
+            setError(e?.message || 'Failed to load documents');
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [apiBaseUrl]);
+    useEffect(() => {
+        fetchDocuments();
+    }, [fetchDocuments]);
+    // Auto-select first doc when list loads
+    useEffect(() => {
+        if (!selectedDoc && documents.length > 0) {
+            setSelectedDoc(documents[0]);
+        }
+    }, [documents, selectedDoc]);
+    useEffect(() => {
+        if (!requestedDocPath || documents.length === 0)
+            return;
+        const requested = normalizeDocPath(requestedDocPath);
+        const matched = documents.find((doc) => {
+            const candidate = normalizeDocPath(doc.fsPath);
+            return docPathMatches(candidate, requested);
+        });
+        if (matched) {
+            setSelectedDoc(matched);
+            onRequestedDocHandled?.();
+            return;
+        }
+    }, [requestedDocPath, documents, onRequestedDocHandled]);
+    const filteredDocs = documents.filter(doc => {
+        const matchesSearch = !searchQuery || doc.title.toLowerCase().includes(searchQuery.toLowerCase());
+        const matchesType = typeFilter === 'all' || doc.docType === typeFilter;
+        return matchesSearch && matchesType;
+    });
+    const taskById = new Map(tasks.map(t => [t.id, t]));
+    return (_jsxs("div", { className: styles.docWorkspace, children: [_jsx("div", { className: styles.docIndexPanel, children: _jsx(DocumentIndex, { documents: filteredDocs, selectedDocId: selectedDoc?.id ?? null, loading: loading, error: error, searchQuery: searchQuery, typeFilter: typeFilter, onSearchChange: setSearchQuery, onTypeFilterChange: setTypeFilter, onSelect: setSelectedDoc, onRefresh: fetchDocuments, taskById: taskById }) }), _jsx("div", { className: styles.docViewerPanel, children: selectedDoc ? (_jsx(DocumentViewer, { doc: selectedDoc, taskTitle: selectedDoc.taskId ? (taskById.get(selectedDoc.taskId)?.title ?? null) : null, apiBaseUrl: apiBaseUrl, onSaved: (_updatedAt) => fetchDocuments() })) : !loading && (_jsx("div", { className: styles.docViewerEmpty, children: _jsx("p", { children: documents.length === 0 ? 'No documents found.' : 'Select a document to view it.' }) })) })] }));
+}

package/dist/components/features/TaskSettings.d.ts

@@ -0,0 +1,209 @@
+import type { TaskforceTheme, CategoryConfig } from '../../types';
+import type { TaxonomyDefinition, Environment } from '../../types';
+interface BuildMetadata {
+    version: string;
+    gitSha: string | null;
+    buildTime: string | null;
+    deployId: string | null;
+}
+export interface TaskSettingsModel {
+    currentTheme: TaskforceTheme;
+    globalTheme: TaskforceTheme;
+    themeUseGlobalDefault: boolean;
+    keyShortcut: string;
+    jsonBackupEnabled: boolean;
+    globalJsonBackupEnabled: boolean;
+    globalWeekStartsOn: 'sunday' | 'monday';
+    locale?: string;
+    supportedLocales?: string[];
+    jsonBackupUseGlobalDefault: boolean;
+    manualComplexityEnabled: boolean;
+    checklistDropdownEnabled?: boolean;
+    assigneeFilterEnabled?: boolean;
+    exportWorkflowsPath: string;
+    exportSpecialistsPath: string;
+    exportingResource: 'workflows' | 'specialists' | null;
+    exportResult: {
+        type: 'success' | 'error';
+        message: string;
+    } | null;
+    initialSection?: 'categories' | 'types' | 'general' | 'documents' | 'commands' | 'workflow-editor' | 'agents' | 'taxonomy' | 'mcp' | 'resources' | 'approaches' | 'priorities' | 'initiatives' | null;
+    exportEnvironment: string;
+    setupState?: {
+        mode: 'core' | 'operations';
+        workspaceId: string;
+        workspace?: {
+            id: string;
+            slug?: string | null;
+            name: string;
+            description?: string | null;
+        } | null;
+    } | null;
+    buildInfo?: BuildMetadata | null;
+    onThemeChange: (theme: TaskforceTheme) => void;
+    onSaveTheme: (theme: TaskforceTheme) => Promise<boolean>;
+    onSaveGlobalTheme: (theme: TaskforceTheme) => Promise<boolean>;
+    onResetProjectToGlobal: () => Promise<boolean>;
+    onKeyShortcutChange: (value: string) => void;
+    onJsonBackupEnabledChange: (value: boolean) => Promise<boolean>;
+    onSaveGlobalJsonBackupEnabled: (value: boolean) => Promise<boolean>;
+    onSaveGlobalWeekStartsOn: (value: 'sunday' | 'monday') => Promise<boolean>;
+    onSaveLocale?: (value: string) => Promise<boolean>;
+    onManualComplexityEnabledChange: (value: boolean) => Promise<boolean>;
+    onChecklistDropdownEnabledChange?: (value: boolean) => Promise<boolean>;
+    onAssigneeFilterEnabledChange?: (value: boolean) => Promise<boolean>;
+    onSaveSettings: () => Promise<boolean>;
+    onSaveSetupMode?: (mode: 'core' | 'operations') => Promise<boolean>;
+    onSaveWorkspaceProfile?: (input: {
+        workspaceId?: string;
+        name: string;
+        description?: string;
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+        code?: string;
+    }>;
+    onExportWorkflowsPathChange: (value: string) => void;
+    onExportSpecialistsPathChange: (value: string) => void;
+    onExportEnvironmentChange: (value: string) => void;
+    onExportResources: (type: 'workflows' | 'specialists', path: string) => void;
+    availableWorkflows?: string[];
+    availableEnvironments?: Environment[];
+    onRefreshWorkflows?: (force?: boolean) => void;
+    onExportWorkflows?: (environment: string, workflows: string[]) => void;
+    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;
+    }>;
+    initiativeTemplates?: Array<{
+        id: string;
+        name: string;
+        description: string;
+        checklistBlocks: {
+            definitionOfDone: string[];
+            rollbackPlan: string[];
+        };
+        milestones: Array<{
+            title: string;
+            description: string;
+            priority?: number;
+            approach?: string;
+            category?: string;
+        }>;
+        defaultSpecialists?: string[];
+    }>;
+    onRefreshInitiativeTemplates?: () => Promise<any>;
+    onCreateInitiativeFromTemplate?: (payload: {
+        templateId: string;
+        title: string;
+        description?: string;
+        category?: string;
+        type?: string;
+        priority?: number;
+        approach?: string;
+        parentTaskId?: string | null;
+        specialists?: string[];
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+        result?: any;
+    }>;
+    onCloneChecklistBlocksToChildren?: (payload: {
+        parentTaskId: string;
+        checklistBlocks: {
+            definitionOfDone: string[];
+            rollbackPlan: string[];
+        };
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+        updated?: number;
+    }>;
+    onShowFolderBrowserChange: (show: boolean) => void;
+    onBrowserTargetChange: (target: 'storage' | {
+        type: 'category';
+        value: string;
+    } | {
+        type: 'context-link';
+    } | null) => void;
+    onFetchFolders: (path: string) => 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;
+    types: {
+        value: string;
+        label: string;
+    }[];
+    onSaveType: (label: string) => void;
+    onRemoveType: (value: string) => void;
+    onSectionChange?: (section: any) => void;
+    taxonomies: TaxonomyDefinition[];
+    onUpdateTaxonomies: (taxonomies: TaxonomyDefinition[]) => 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;
+    projectRoot?: string;
+    projectName?: string;
+    mcpHostRoot?: string;
+    serverHostRoot?: string;
+    mcpScriptPath?: string;
+    tenantId?: string;
+    workspaceId?: string;
+    runtimeMode?: 'local' | 'cloud';
+    workspaceSwitchingEnabled?: boolean;
+    currentWorkspaceRole?: 'owner' | 'admin' | 'member' | 'read-only';
+    currentWorkspaceName?: string;
+    onDeleteWorkspace?: (workspaceId: string) => Promise<{
+        success: boolean;
+        error?: string;
+        code?: string;
+        nextWorkspaceId?: string;
+        workspaceSetupRequired?: boolean;
+        cleanupWarnings?: string[];
+    }>;
+    onMcpHostRootChange?: (value: string) => void;
+    isAuthenticated?: boolean;
+}
+interface TaskSettingsProps {
+    settingsModel: TaskSettingsModel;
+    onSectionChange?: (section: any) => void;
+}
+export declare function TaskSettings(props: TaskSettingsProps): import("react/jsx-runtime").JSX.Element;
+export {};