@taskforcehq/taskforce 0.3.168

package/dist/components/task/TaskContextUpload.js

@@ -0,0 +1,393 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { AlertTriangle, Copy, FileUp, Loader2, Trash2, ChevronDown, ChevronRight } from 'lucide-react';
+import styles from '../../Taskforce.module.css';
+import { dispatchOpenMarkdownDocument } from '../../utils/contextFiles';
+const ACCEPTED_CONTEXT_FILE_TYPES = [
+    '.png', '.jpg', '.jpeg', '.webp', '.gif',
+    '.pdf', '.txt', '.md', '.csv', '.json', '.doc', '.docx',
+    '.html', '.js', '.ts', '.tsx', '.css', '.py', '.java', '.go', '.rs', '.sh'
+].join(',');
+const ACCEPTED_CONTEXT_EXTENSIONS = new Set(ACCEPTED_CONTEXT_FILE_TYPES.split(',').map((ext) => ext.trim().toLowerCase()));
+const MAX_CONTEXT_FILE_SIZE_BYTES = 10 * 1024 * 1024; // 10 MB per file
+const CONTEXT_NOTICE_TIMEOUT_MS = 3500;
+function getFileExtension(fileName) {
+    const trimmed = fileName.trim().toLowerCase();
+    const dotIdx = trimmed.lastIndexOf('.');
+    if (dotIdx === -1)
+        return '';
+    return trimmed.slice(dotIdx);
+}
+function formatFileList(fileNames) {
+    if (fileNames.length === 0)
+        return '';
+    const shown = fileNames.slice(0, 3).join(', ');
+    const extra = fileNames.length - 3;
+    return extra > 0 ? `${shown}, +${extra} more` : shown;
+}
+function getLocalFileFingerprint(file) {
+    return `${file.name.trim().toLowerCase()}::${file.size}::${file.lastModified}`;
+}
+function readFileAsDataUrl(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(String(reader.result || ''));
+        reader.onerror = () => reject(reader.error || new Error('Failed to read file'));
+        reader.readAsDataURL(file);
+    });
+}
+function isImagePath(path) {
+    return /\.(png|jpe?g|webp|gif)(\?|#|$)/i.test(path);
+}
+export function TaskContextUpload(props) {
+    const { taskId, contextFiles, browsedPath, onBrowseLinkPath, onAddContextFile, onRemoveContextFile, onUpdateContextCaption } = props;
+    const inputRef = useRef(null);
+    const [uploading, setUploading] = useState(false);
+    const [uploadError, setUploadError] = useState(null);
+    const [linkValue, setLinkValue] = useState('');
+    const [linkError, setLinkError] = useState(null);
+    const [contextNotice, setContextNotice] = useState(null);
+    const [showContextUpload, setShowContextUpload] = useState(false);
+    const [isDropActive, setIsDropActive] = useState(false);
+    const [dragDepth, setDragDepth] = useState(0);
+    const contextKeyRef = useRef(new Set());
+    const localUploadFingerprintRef = useRef(new Set());
+    const normalizeKey = (value) => (value || '').trim();
+    const getContextKeys = (path, fsPath) => {
+        const keys = [];
+        const normalizedPath = normalizeKey(path);
+        const normalizedFsPath = normalizeKey(fsPath);
+        if (normalizedPath)
+            keys.push(`path:${normalizedPath}`);
+        if (normalizedFsPath)
+            keys.push(`fs:${normalizedFsPath}`);
+        return keys;
+    };
+    const keySetFromFiles = useMemo(() => {
+        const next = new Set();
+        contextFiles.forEach((item) => {
+            if (typeof item === 'string') {
+                getContextKeys(item).forEach((key) => next.add(key));
+                return;
+            }
+            getContextKeys(item.path, item.fsPath).forEach((key) => next.add(key));
+        });
+        return next;
+    }, [contextFiles]);
+    useEffect(() => {
+        contextKeyRef.current = new Set(keySetFromFiles);
+    }, [keySetFromFiles]);
+    const hasAnyKey = (set, keys) => keys.some((key) => set.has(key));
+    const addKeys = (set, keys) => keys.forEach((key) => set.add(key));
+    const addLink = (rawValue, clearInput = true, contextKeySet = contextKeyRef.current) => {
+        const trimmed = rawValue.trim();
+        if (!trimmed)
+            return 'invalid';
+        const isHttp = /^https?:\/\//i.test(trimmed);
+        const normalizedPath = isHttp
+            ? trimmed
+            : `/api/taskforce/context-link?path=${encodeURIComponent(trimmed)}`;
+        const fsPath = isHttp ? undefined : trimmed;
+        const keys = getContextKeys(normalizedPath, fsPath);
+        if (hasAnyKey(contextKeySet, keys))
+            return 'duplicate';
+        const nameFromPath = trimmed.split(/[\\/]/).pop() || trimmed;
+        onAddContextFile({
+            path: normalizedPath,
+            fsPath,
+            caption: nameFromPath,
+            timestamp: new Date().toISOString()
+        });
+        addKeys(contextKeySet, keys);
+        if (clearInput)
+            setLinkValue('');
+        setLinkError(null);
+        return 'added';
+    };
+    useEffect(() => {
+        if (!browsedPath)
+            return;
+        const result = addLink(browsedPath, true);
+        if (result === 'duplicate') {
+            setContextNotice('Link already exists in task context.');
+        }
+        else if (result === 'added') {
+            setContextNotice(null);
+        }
+    }, [browsedPath]);
+    useEffect(() => {
+        if (!contextNotice)
+            return;
+        const timeoutId = window.setTimeout(() => {
+            setContextNotice(null);
+        }, CONTEXT_NOTICE_TIMEOUT_MS);
+        return () => window.clearTimeout(timeoutId);
+    }, [contextNotice]);
+    const handleFilesSelected = async (files) => {
+        if (!files || files.length === 0)
+            return;
+        setUploadError(null);
+        setContextNotice(null);
+        const selectedFiles = Array.from(files);
+        const unsupportedFiles = [];
+        const oversizedFiles = [];
+        const localDuplicateFiles = [];
+        const uploadCandidates = [];
+        const localFingerprintSet = new Set(localUploadFingerprintRef.current);
+        selectedFiles.forEach((file) => {
+            const ext = getFileExtension(file.name);
+            if (!ACCEPTED_CONTEXT_EXTENSIONS.has(ext)) {
+                unsupportedFiles.push(file.name);
+                return;
+            }
+            if (file.size > MAX_CONTEXT_FILE_SIZE_BYTES) {
+                oversizedFiles.push(file.name);
+                return;
+            }
+            const fingerprint = getLocalFileFingerprint(file);
+            if (localFingerprintSet.has(fingerprint)) {
+                localDuplicateFiles.push(file.name);
+                return;
+            }
+            localFingerprintSet.add(fingerprint);
+            uploadCandidates.push({ file, fingerprint });
+        });
+        const validationNotices = [];
+        if (unsupportedFiles.length > 0) {
+            validationNotices.push(`${unsupportedFiles.length} unsupported file${unsupportedFiles.length === 1 ? '' : 's'} skipped: ${formatFileList(unsupportedFiles)}.`);
+        }
+        if (oversizedFiles.length > 0) {
+            validationNotices.push(`${oversizedFiles.length} file${oversizedFiles.length === 1 ? '' : 's'} over 10 MB skipped: ${formatFileList(oversizedFiles)}.`);
+        }
+        if (localDuplicateFiles.length > 0) {
+            validationNotices.push(`${localDuplicateFiles.length} local duplicate file${localDuplicateFiles.length === 1 ? '' : 's'} skipped before upload: ${formatFileList(localDuplicateFiles)}.`);
+        }
+        if (uploadCandidates.length === 0) {
+            if (validationNotices.length > 0)
+                setContextNotice(validationNotices.join(' '));
+            if (inputRef.current)
+                inputRef.current.value = '';
+            return;
+        }
+        setUploading(true);
+        const contextKeySet = new Set(contextKeyRef.current);
+        let duplicateCount = 0;
+        try {
+            for (const { file, fingerprint } of uploadCandidates) {
+                let data = null;
+                const initRes = await fetch('/api/taskforce/context-upload/init', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        originalName: file.name,
+                        mimeType: file.type || 'application/octet-stream',
+                        size: file.size,
+                        taskId: taskId || null
+                    })
+                });
+                if (initRes.ok) {
+                    const initData = await initRes.json();
+                    if (initData?.success && typeof initData?.uploadUrl === 'string' && typeof initData?.path === 'string') {
+                        const uploadRes = await fetch(initData.uploadUrl, {
+                            method: String(initData.method || 'PUT'),
+                            headers: initData.headers || { 'Content-Type': file.type || 'application/octet-stream' },
+                            body: file
+                        });
+                        if (!uploadRes.ok) {
+                            throw new Error(`Upload failed for ${file.name}`);
+                        }
+                        const finalizeRes = await fetch('/api/taskforce/context-upload/finalize', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                relativePath: initData.relativePath,
+                                mimeType: file.type || 'application/octet-stream',
+                                originalName: file.name,
+                                size: file.size
+                            })
+                        });
+                        if (!finalizeRes.ok) {
+                            const finalizeError = await finalizeRes.json().catch(() => ({}));
+                            throw new Error(finalizeError?.error || `Upload failed for ${file.name}`);
+                        }
+                        data = {
+                            success: true,
+                            path: initData.path,
+                            fsPath: initData.fsPath
+                        };
+                    }
+                    else if (initData?.success && typeof initData?.path === 'string') {
+                        data = initData;
+                    }
+                }
+                if (!data) {
+                    const encoded = await readFileAsDataUrl(file);
+                    const res = await fetch('/api/taskforce/context-upload', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            file: encoded,
+                            originalName: file.name,
+                            taskId: taskId || null
+                        })
+                    });
+                    if (!res.ok) {
+                        throw new Error(`Upload failed for ${file.name}`);
+                    }
+                    data = await res.json();
+                }
+                if (!data?.success || !data?.path) {
+                    throw new Error(`Upload failed for ${file.name}`);
+                }
+                const keys = getContextKeys(data.path, data.fsPath);
+                if (hasAnyKey(contextKeySet, keys)) {
+                    duplicateCount += 1;
+                    continue;
+                }
+                onAddContextFile({
+                    path: data.path,
+                    fsPath: data.fsPath,
+                    caption: file.name,
+                    timestamp: new Date().toISOString()
+                });
+                addKeys(contextKeySet, keys);
+                localUploadFingerprintRef.current.add(fingerprint);
+            }
+            const notices = [...validationNotices];
+            if (duplicateCount > 0) {
+                notices.push(`${duplicateCount} duplicate file${duplicateCount === 1 ? '' : 's'} skipped.`);
+            }
+            setContextNotice(notices.length > 0 ? notices.join(' ') : null);
+            contextKeyRef.current = contextKeySet;
+        }
+        catch (error) {
+            setUploadError(error instanceof Error ? error.message : 'Failed to upload context file');
+        }
+        finally {
+            setUploading(false);
+            if (inputRef.current)
+                inputRef.current.value = '';
+        }
+    };
+    const parseDroppedLinks = (event) => {
+        const droppedLinks = new Set();
+        const rawUriList = event.dataTransfer.getData('text/uri-list') || '';
+        const rawText = event.dataTransfer.getData('text/plain') || '';
+        const candidates = `${rawUriList}\n${rawText}`
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => !!line && !line.startsWith('#'));
+        for (const candidate of candidates) {
+            if (/^file:\/\//i.test(candidate)) {
+                try {
+                    const fileUrl = new URL(candidate);
+                    const fsPath = decodeURIComponent(fileUrl.pathname || '').trim();
+                    if (fsPath)
+                        droppedLinks.add(fsPath);
+                }
+                catch {
+                    // Ignore malformed file URL drops
+                }
+                continue;
+            }
+            droppedLinks.add(candidate);
+        }
+        return Array.from(droppedLinks);
+    };
+    const handleDrop = (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        setIsDropActive(false);
+        setDragDepth(0);
+        setUploadError(null);
+        setLinkError(null);
+        setContextNotice(null);
+        if (event.dataTransfer.files && event.dataTransfer.files.length > 0) {
+            void handleFilesSelected(event.dataTransfer.files);
+            return;
+        }
+        const droppedLinks = parseDroppedLinks(event);
+        if (droppedLinks.length === 0) {
+            setLinkError('Drop a file, URL, or file path.');
+            return;
+        }
+        const contextKeySet = new Set(contextKeyRef.current);
+        let duplicateCount = 0;
+        let addedCount = 0;
+        droppedLinks.forEach((link) => {
+            const result = addLink(link, false, contextKeySet);
+            if (result === 'duplicate')
+                duplicateCount += 1;
+            if (result === 'added')
+                addedCount += 1;
+        });
+        if (duplicateCount > 0) {
+            setContextNotice(`${duplicateCount} duplicate link${duplicateCount === 1 ? '' : 's'} skipped.`);
+        }
+        else if (addedCount > 0) {
+            setContextNotice(null);
+        }
+        contextKeyRef.current = contextKeySet;
+    };
+    const handleDragEnter = (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        setDragDepth((depth) => depth + 1);
+        setIsDropActive(true);
+    };
+    const handleDragLeave = (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        setDragDepth((depth) => {
+            const nextDepth = Math.max(0, depth - 1);
+            if (nextDepth === 0)
+                setIsDropActive(false);
+            return nextDepth;
+        });
+    };
+    const handleDragOver = (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        event.dataTransfer.dropEffect = 'copy';
+    };
+    return (_jsxs("div", { className: styles.specialistSection, children: [_jsxs("div", { className: styles.toggleHeading, onClick: () => setShowContextUpload(!showContextUpload), title: showContextUpload ? 'Hide context documents' : 'Show context documents', children: [_jsxs("label", { className: styles.label, children: ["Context Documents ", contextFiles.length > 0 && `(${contextFiles.length})`] }), showContextUpload ? _jsx(ChevronDown, { size: 14 }) : _jsx(ChevronRight, { size: 14 })] }), showContextUpload && (_jsxs(_Fragment, { children: [_jsx("p", { className: styles.settingsHint, children: "Upload copies into context storage, or link to existing files/URLs without copying." }), _jsxs("div", { className: styles.contextUploadActions, children: [_jsxs("button", { type: "button", className: styles.secondaryHeaderBtn, onClick: () => inputRef.current?.click(), disabled: uploading, children: [uploading ? _jsx(Loader2, { size: 12, className: styles.spinner }) : _jsx(FileUp, { size: 12 }), uploading ? 'Uploading...' : 'Upload File'] }), _jsx("button", { type: "button", className: styles.secondaryHeaderBtn, onClick: () => onBrowseLinkPath?.(), children: "Browse Link" })] }), _jsx("input", { ref: inputRef, type: "file", accept: ACCEPTED_CONTEXT_FILE_TYPES, multiple: true, className: styles.hiddenInput, onChange: (e) => {
+                            void handleFilesSelected(e.target.files);
+                        } }), uploadError && _jsx("div", { className: styles.error, children: uploadError }), _jsxs("div", { className: styles.contextLinkRow, children: [_jsx("input", { type: "text", className: styles.input, placeholder: "Link file path (e.g. docs/spec.pdf) or URL (https://...)", value: linkValue, onChange: (e) => {
+                                    setLinkValue(e.target.value);
+                                    if (linkError)
+                                        setLinkError(null);
+                                    if (contextNotice)
+                                        setContextNotice(null);
+                                } }), _jsx("button", { type: "button", className: styles.secondaryHeaderBtn, onClick: () => {
+                                    if (!linkValue.trim()) {
+                                        setLinkError('Enter a file path or URL to link.');
+                                        return;
+                                    }
+                                    const result = addLink(linkValue, true);
+                                    if (result === 'duplicate') {
+                                        setContextNotice('Link already exists in task context.');
+                                    }
+                                    else if (result === 'added') {
+                                        setContextNotice(null);
+                                    }
+                                }, children: "Save Link" })] }), _jsxs("div", { className: `${styles.contextDropzone} ${isDropActive ? styles.contextDropzoneActive : ''}`, onDragEnter: handleDragEnter, onDragLeave: handleDragLeave, onDragOver: handleDragOver, onDrop: handleDrop, children: [_jsx(FileUp, { size: 14 }), _jsx("span", { children: "Drop files, URLs, or file paths here" })] }), contextNotice && _jsx("div", { className: styles.contextNotice, children: contextNotice }), linkError && _jsx("div", { className: styles.error, children: linkError }), contextFiles.length > 0 && (_jsx("div", { className: styles.screenshotGrid, children: contextFiles.map((item, idx) => {
+                            const path = typeof item === 'string' ? item : item.path;
+                            const fsPath = typeof item === 'string' ? undefined : item.fsPath;
+                            const caption = typeof item === 'string' ? '' : item.caption || '';
+                            const isImage = isImagePath(path);
+                            return (_jsxs("div", { className: styles.screenshotCard, children: [_jsxs("div", { className: styles.screenshotImageContainer, children: [isImage ? (_jsx("img", { src: path, alt: caption || `Context file ${idx}`, onClick: () => window.open(path, '_blank'), onError: (e) => {
+                                                    e.target.style.display = 'none';
+                                                    e.target.parentElement.classList.add(styles.brokenImage);
+                                                } })) : (_jsxs("button", { type: "button", className: styles.contextFileLink, onClick: () => {
+                                                    if (dispatchOpenMarkdownDocument(path, fsPath))
+                                                        return;
+                                                    window.open(path, '_blank');
+                                                }, title: "Open file", children: [_jsx(FileUp, { size: 16 }), _jsx("span", { children: caption || fsPath || path.split('/').pop() || 'Context file' })] })), _jsxs("div", { className: styles.brokenImagePlaceholder, children: [_jsx(AlertTriangle, { size: 16 }), _jsx("span", { children: "Preview unavailable" })] }), _jsxs("div", { className: styles.screenshotActions, children: [fsPath && (_jsx("button", { type: "button", className: styles.screenshotActionBtn, onClick: (e) => {
+                                                            e.stopPropagation();
+                                                            navigator.clipboard.writeText(fsPath);
+                                                        }, title: `Copy path: ${fsPath}`, children: _jsx(Copy, { size: 12 }) })), _jsx("button", { type: "button", className: styles.screenshotActionBtn, onClick: (e) => {
+                                                            e.stopPropagation();
+                                                            onRemoveContextFile(idx);
+                                                        }, title: "Delete", children: _jsx(Trash2, { size: 12 }) })] })] }), _jsx("input", { type: "text", className: styles.screenshotCaptionInput, placeholder: "Add a label...", value: caption, onChange: (e) => onUpdateContextCaption(idx, e.target.value) })] }, idx));
+                        }) }))] }))] }));
+}

package/dist/components/task/TaskContextUpload.test.d.ts

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

package/dist/components/task/TaskContextUpload.test.js

@@ -0,0 +1,189 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { TaskContextUpload } from './TaskContextUpload';
+class MockFileReader {
+    result = null;
+    error = null;
+    onload = null;
+    onerror = null;
+    readAsDataURL(_file) {
+        this.result = 'data:application/octet-stream;base64,ZmFrZQ==';
+        this.onload?.call(this, new ProgressEvent('load'));
+    }
+}
+const createFileList = (files) => {
+    const list = {
+        length: files.length,
+        item: (index) => files[index] || null
+    };
+    files.forEach((file, index) => {
+        list[index] = file;
+    });
+    list[Symbol.iterator] = () => files.values();
+    return list;
+};
+describe('TaskContextUpload drag and drop', () => {
+    const CONTEXT_UPLOAD_OPEN_STORAGE_KEY = 'taskforce-show-context-upload';
+    const onAddContextFile = vi.fn();
+    const onRemoveContextFile = vi.fn();
+    const onUpdateContextCaption = vi.fn();
+    const onBrowseLinkPath = vi.fn();
+    const renderUpload = (contextFiles = []) => render(_jsx(TaskContextUpload, { contextFiles: contextFiles, onBrowseLinkPath: onBrowseLinkPath, onAddContextFile: onAddContextFile, onRemoveContextFile: onRemoveContextFile, onUpdateContextCaption: onUpdateContextCaption }));
+    const openSection = async () => {
+        const user = userEvent.setup();
+        const showToggle = screen.queryByTitle('Show context documents');
+        if (showToggle) {
+            await user.click(showToggle);
+        }
+        return screen.getByText('Drop files, URLs, or file paths here');
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.stubGlobal('FileReader', MockFileReader);
+        window.localStorage.removeItem(CONTEXT_UPLOAD_OPEN_STORAGE_KEY);
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('adds dropped URL links', async () => {
+        renderUpload();
+        const dropzone = await openSection();
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([]),
+                getData: (type) => (type === 'text/plain' ? 'https://example.com/spec' : '')
+            }
+        });
+        expect(onAddContextFile).toHaveBeenCalledTimes(1);
+        expect(onAddContextFile).toHaveBeenCalledWith(expect.objectContaining({
+            path: 'https://example.com/spec',
+            caption: 'spec'
+        }));
+    });
+    it('converts dropped file:// URLs to linked filesystem paths', async () => {
+        renderUpload();
+        const dropzone = await openSection();
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([]),
+                getData: (type) => type === 'text/uri-list' ? 'file:///Users/rossburke/Documents/spec.pdf' : ''
+            }
+        });
+        expect(onAddContextFile).toHaveBeenCalledTimes(1);
+        expect(onAddContextFile).toHaveBeenCalledWith(expect.objectContaining({
+            path: '/api/taskforce/context-link?path=%2FUsers%2Frossburke%2FDocuments%2Fspec.pdf',
+            fsPath: '/Users/rossburke/Documents/spec.pdf',
+            caption: 'spec.pdf'
+        }));
+    });
+    it('shows an error for empty drops', async () => {
+        renderUpload();
+        const dropzone = await openSection();
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([]),
+                getData: () => ''
+            }
+        });
+        expect(screen.getByText('Drop a file, URL, or file path.')).toBeInTheDocument();
+    });
+    it('skips duplicate dropped links and shows notice', async () => {
+        renderUpload();
+        const dropzone = await openSection();
+        const dataTransfer = {
+            files: createFileList([]),
+            getData: (type) => (type === 'text/plain' ? 'https://example.com/spec' : '')
+        };
+        fireEvent.drop(dropzone, { dataTransfer });
+        fireEvent.drop(dropzone, { dataTransfer });
+        expect(onAddContextFile).toHaveBeenCalledTimes(1);
+        expect(screen.getByText('1 duplicate link skipped.')).toBeInTheDocument();
+    });
+    it('skips duplicate uploaded files and shows notice', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                success: true,
+                path: '/api/taskforce/context/shared.pdf',
+                fsPath: 'context-files/shared.pdf'
+            })
+        }));
+        renderUpload();
+        const dropzone = await openSection();
+        const fileA = new File(['a'], 'one.pdf', { type: 'application/pdf' });
+        const fileB = new File(['b'], 'two.pdf', { type: 'application/pdf' });
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([fileA, fileB]),
+                getData: () => ''
+            }
+        });
+        await waitFor(() => {
+            expect(onAddContextFile).toHaveBeenCalledTimes(1);
+        });
+        expect(screen.getByText('1 duplicate file skipped.')).toBeInTheDocument();
+    });
+    it('validates unsupported file types before upload', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        renderUpload();
+        const dropzone = await openSection();
+        const file = new File(['bad'], 'script.exe', { type: 'application/octet-stream' });
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([file]),
+                getData: () => ''
+            }
+        });
+        expect(onAddContextFile).not.toHaveBeenCalled();
+        expect(fetchMock).not.toHaveBeenCalled();
+        expect(screen.getByText(/unsupported file/i)).toBeInTheDocument();
+        expect(screen.getByText(/script\.exe/i)).toBeInTheDocument();
+    });
+    it('validates oversized files before upload', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        renderUpload();
+        const dropzone = await openSection();
+        const largePayload = new Uint8Array(10 * 1024 * 1024 + 1);
+        const file = new File([largePayload], 'huge.pdf', { type: 'application/pdf' });
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([file]),
+                getData: () => ''
+            }
+        });
+        expect(onAddContextFile).not.toHaveBeenCalled();
+        expect(fetchMock).not.toHaveBeenCalled();
+        expect(screen.getByText(/over 10 mb/i)).toBeInTheDocument();
+        expect(screen.getByText(/huge\.pdf/i)).toBeInTheDocument();
+    });
+    it('skips local duplicate files before upload network calls', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                success: true,
+                path: '/api/taskforce/context/dup.pdf',
+                fsPath: 'context-files/dup.pdf'
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        renderUpload();
+        const dropzone = await openSection();
+        const duplicateA = new File(['same-data'], 'dup.pdf', { type: 'application/pdf', lastModified: 1739366400000 });
+        const duplicateB = new File(['same-data'], 'dup.pdf', { type: 'application/pdf', lastModified: 1739366400000 });
+        fireEvent.drop(dropzone, {
+            dataTransfer: {
+                files: createFileList([duplicateA, duplicateB]),
+                getData: () => ''
+            }
+        });
+        await waitFor(() => {
+            expect(onAddContextFile).toHaveBeenCalledTimes(1);
+        });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(screen.getByText(/local duplicate file/i)).toBeInTheDocument();
+    });
+});