@taskforcehq/taskforce 0.3.168

package/dist/TaskforceScreenshot.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface ScreenshotCallbackData {
+    path: string;
+    fsPath?: string;
+}
+interface TaskforceScreenshotProps {
+    onCapture: (data: string | ScreenshotCallbackData) => void;
+    onCancel: () => void;
+}
+export declare const TaskforceScreenshot: React.FC<TaskforceScreenshotProps>;
+export {};

package/dist/TaskforceScreenshot.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { createPortal } from 'react-dom';
+import html2canvas from 'html2canvas';
+import { Camera, X, Check, Loader2 } from 'lucide-react';
+import styles from './Taskforce.module.css';
+export const TaskforceScreenshot = ({ onCapture, onCancel }) => {
+    const [preview, setPreview] = useState(null);
+    const [isCapturing, setIsCapturing] = useState(false);
+    const [isSaving, setIsSaving] = useState(false);
+    const [isSelectingRegion, setIsSelectingRegion] = useState(false);
+    const [selectionStart, setSelectionStart] = useState(null);
+    const [selectionCurrent, setSelectionCurrent] = useState(null);
+    const handleCapture = async (crop) => {
+        setIsCapturing(true);
+        try {
+            const options = {
+                useCORS: true,
+                scale: window.devicePixelRatio,
+                ignoreElements: (element) => {
+                    return (element.id === 'taskforce-root' ||
+                        element.classList.contains(styles.regionOverlay) ||
+                        element.classList.contains(styles.overlay));
+                }
+            };
+            if (crop) {
+                options.x = crop.x;
+                options.y = crop.y;
+                options.width = crop.width;
+                options.height = crop.height;
+                // Important: windowWidth/windowHeight should match viewport if cropping to ensure correct rendering
+                options.windowWidth = document.documentElement.scrollWidth;
+                options.windowHeight = document.documentElement.scrollHeight;
+            }
+            const canvas = await html2canvas(document.body, options);
+            const imgData = canvas.toDataURL('image/png');
+            setPreview(imgData);
+        }
+        catch (error) {
+            console.error('Screenshot capture failed:', error);
+        }
+        finally {
+            setIsCapturing(false);
+            setIsSelectingRegion(false);
+            setSelectionStart(null);
+            setSelectionCurrent(null);
+        }
+    };
+    const handleMouseDown = (e) => {
+        setSelectionStart({ x: e.clientX, y: e.clientY });
+        setSelectionCurrent({ x: e.clientX, y: e.clientY });
+    };
+    const handleMouseMove = (e) => {
+        if (selectionStart) {
+            setSelectionCurrent({ x: e.clientX, y: e.clientY });
+        }
+    };
+    const handleMouseUp = () => {
+        if (selectionStart && selectionCurrent) {
+            const x = Math.min(selectionStart.x, selectionCurrent.x);
+            const y = Math.min(selectionStart.y, selectionCurrent.y);
+            const width = Math.abs(selectionCurrent.x - selectionStart.x);
+            const height = Math.abs(selectionCurrent.y - selectionStart.y);
+            // Add scroll offset to capturing coordinates
+            const scrollX = window.scrollX;
+            const scrollY = window.scrollY;
+            if (width > 10 && height > 10) {
+                handleCapture({ x: x + scrollX, y: y + scrollY, width, height });
+            }
+            else {
+                // Too small, cancel selection
+                setIsSelectingRegion(false);
+                setSelectionStart(null);
+                setSelectionCurrent(null);
+            }
+        }
+    };
+    const handleCancel = () => {
+        setPreview(null);
+        setIsSelectingRegion(false);
+        setSelectionStart(null);
+        setSelectionCurrent(null);
+        onCancel();
+    };
+    const handleConfirm = async () => {
+        if (!preview)
+            return;
+        setIsSaving(true);
+        try {
+            const res = await fetch('/api/taskforce/screenshot', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ image: preview })
+            });
+            const data = await res.json();
+            if (data.success) {
+                onCapture({ path: data.path, fsPath: data.fsPath });
+            }
+        }
+        catch (error) {
+            console.error('Failed to save screenshot:', error);
+        }
+        finally {
+            setIsSaving(false);
+        }
+    };
+    return (_jsxs(_Fragment, { children: [isSelectingRegion && createPortal(_jsx("div", { className: styles.regionOverlay, onMouseDown: handleMouseDown, onMouseMove: handleMouseMove, onMouseUp: handleMouseUp, children: selectionStart && selectionCurrent && (_jsx("div", { className: styles.selectionBox, style: {
+                        left: Math.min(selectionStart.x, selectionCurrent.x),
+                        top: Math.min(selectionStart.y, selectionCurrent.y),
+                        width: Math.abs(selectionCurrent.x - selectionStart.x),
+                        height: Math.abs(selectionCurrent.y - selectionStart.y),
+                    } })) }), document.body), _jsx("div", { className: styles.screenshotContainer, children: !preview ? (_jsxs("div", { className: styles.capturePrompt, children: [_jsxs("p", { children: [isCapturing && _jsx(Loader2, { className: styles.spin, size: 14, style: { display: 'inline', marginRight: '8px', verticalAlign: 'text-bottom' } }), isCapturing ? 'Capturing...' : 'Ready to capture the current screen context?'] }), _jsxs("div", { className: styles.actions, children: [_jsxs("button", { type: "button", className: styles.secondaryButton, onClick: handleCancel, disabled: isCapturing, children: [_jsx(X, { size: 16 }), " Cancel"] }), _jsxs("button", { type: "button", className: styles.secondaryButton, onClick: () => setIsSelectingRegion(true), disabled: isCapturing, children: [_jsx(Camera, { size: 16 }), " Select Area"] }), _jsxs("button", { type: "button", className: styles.secondaryButton, onClick: () => handleCapture(), disabled: isCapturing, children: [_jsx(Camera, { size: 16 }), "Capture Full"] })] })] })) : (_jsxs("div", { className: styles.previewContainer, children: [_jsxs("div", { className: styles.previewHeader, children: [_jsx("span", { children: "Screenshot Preview" }), _jsx("button", { type: "button", className: styles.iconButton, onClick: handleCancel, children: _jsx(X, { size: 16 }) })] }), _jsx("img", { src: preview, alt: "Captured", className: styles.screenshotPreview }), _jsxs("div", { className: styles.actions, children: [_jsx("button", { type: "button", className: styles.secondaryButton, onClick: handleCancel, disabled: isSaving, children: "Discard" }), _jsxs("button", { type: "button", className: styles.primaryButton, onClick: handleConfirm, disabled: isSaving, children: [isSaving ? _jsx(Loader2, { className: styles.spin, size: 16 }) : _jsx(Check, { size: 16 }), isSaving ? 'Saving...' : 'Use Screenshot'] })] })] })) })] }));
+};

package/dist/TaskforceWidget.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { TaskforceConfig } from './types';
+export interface TaskforceWidgetProps {
+    config?: Partial<TaskforceConfig>;
+}
+export declare const TaskforceWidget: React.FC<TaskforceWidgetProps>;

package/dist/TaskforceWidget.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { ClipboardList } from 'lucide-react';
+import { TaskforceCore } from './TaskforceCore';
+import styles from './Taskforce.module.css';
+import { DEFAULT_CONFIG } from './types';
+export const TaskforceWidget = ({ config = {} }) => {
+    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+    const { shortcut: configShortcut } = mergedConfig;
+    const [isOpen, setIsOpen] = useState(false);
+    const [taskCount, setTaskCount] = useState(0);
+    // Draggable logic for the widget modal
+    const modalRef = useRef(null);
+    const [position, setPosition] = useState({ x: 0, y: 0 });
+    const [isDragging, setIsDragging] = useState(false);
+    const [dragStart, setDragStart] = useState({ x: 0, y: 0 });
+    const [initialTop, setInitialTop] = useState(0);
+    const handleMouseDown = (e) => {
+        // Prevent drag if clicking buttons or inputs within the header
+        if (e.target.closest('button'))
+            return;
+        if (modalRef.current) {
+            const rect = modalRef.current.getBoundingClientRect();
+            setInitialTop(rect.top - position.y);
+        }
+        setIsDragging(true);
+        setDragStart({
+            x: e.clientX - position.x,
+            y: e.clientY - position.y
+        });
+    };
+    const handleMouseMove = useCallback((e) => {
+        if (isDragging) {
+            let newX = e.clientX - dragStart.x;
+            let newY = e.clientY - dragStart.y;
+            if (newY < -initialTop) {
+                newY = -initialTop;
+            }
+            setPosition({ x: newX, y: newY });
+        }
+    }, [isDragging, dragStart, initialTop]);
+    const handleMouseUp = useCallback(() => {
+        setIsDragging(false);
+    }, []);
+    useEffect(() => {
+        if (isDragging) {
+            window.addEventListener('mousemove', handleMouseMove);
+            window.addEventListener('mouseup', handleMouseUp);
+        }
+        else {
+            window.removeEventListener('mousemove', handleMouseMove);
+            window.removeEventListener('mouseup', handleMouseUp);
+        }
+        return () => {
+            window.removeEventListener('mousemove', handleMouseMove);
+            window.removeEventListener('mouseup', handleMouseUp);
+        };
+    }, [isDragging, handleMouseMove, handleMouseUp]);
+    // Keyboard shortcut handler
+    const handleKeyDown = useCallback((e) => {
+        const keys = (configShortcut || 'Alt+T').toLowerCase().split('+').map(k => k.trim());
+        const key = keys[keys.length - 1];
+        const modifiers = keys.slice(0, keys.length - 1);
+        const hasAlt = modifiers.includes('alt') || modifiers.includes('option');
+        const hasCtrl = modifiers.includes('ctrl') || modifiers.includes('control');
+        const hasShift = modifiers.includes('shift');
+        const hasMeta = modifiers.includes('meta') || modifiers.includes('cmd') || modifiers.includes('command');
+        if ((e.key.toLowerCase() === key || e.code.toLowerCase() === `key${key}`) &&
+            (hasAlt === e.altKey) &&
+            (hasCtrl === e.ctrlKey) &&
+            (hasShift === e.shiftKey) &&
+            (hasMeta === e.metaKey)) {
+            e.preventDefault();
+            setIsOpen(prev => !prev);
+        }
+    }, [configShortcut]);
+    useEffect(() => {
+        window.addEventListener('keydown', handleKeyDown);
+        return () => window.removeEventListener('keydown', handleKeyDown);
+    }, [handleKeyDown]);
+    // Body scroll lock
+    useEffect(() => {
+        if (isOpen) {
+            const originalStyle = window.getComputedStyle(document.body).overflow;
+            document.body.style.overflow = 'hidden';
+            return () => {
+                document.body.style.overflow = originalStyle;
+            };
+        }
+        return undefined;
+    }, [isOpen]);
+    // Only render in development
+    if (!import.meta.env.DEV) {
+        return null;
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs("button", { className: styles.floatingButton, onClick: () => setIsOpen(!isOpen), title: `Taskforce (${configShortcut})`, children: [_jsx(ClipboardList, { size: 22 }), taskCount > 0 && (_jsx("span", { className: styles.badge, children: taskCount }))] }), _jsx("div", { id: "taskforce-root", className: `${styles.overlay} ${styles.widgetOverlay}`, style: {
+                    display: isOpen ? 'flex' : 'none',
+                }, children: _jsx("div", { ref: modalRef, className: `${styles.modal} ${styles.widgetModal}`, style: {
+                        transform: `translate(${position.x}px, ${position.y}px)`,
+                    }, children: _jsx(TaskforceCore, { config: config, mode: "standalone", onHeaderMouseDown: handleMouseDown, isDragging: isDragging, onTaskCountChange: setTaskCount, onClose: () => setIsOpen(false) }) }) })] }));
+};

package/dist/TaskforceWidget.test.d.ts

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

package/dist/TaskforceWidget.test.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } 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 } from 'vitest';
+import React from 'react';
+import { TaskforceWidget } from './TaskforceWidget';
+// Mock TaskforceCore to avoid testing integration twice
+vi.mock('./TaskforceCore', () => ({
+    TaskforceCore: ({ onTaskCountChange, onHeaderMouseDown, onClose }) => {
+        // Report a count of 3 on mount
+        React.useEffect(() => {
+            if (onTaskCountChange)
+                onTaskCountChange(3);
+        }, [onTaskCountChange]);
+        return (_jsxs("div", { "data-testid": "core-component", children: [_jsx("div", { "data-testid": "header", onMouseDown: onHeaderMouseDown, children: "Header" }), _jsx("button", { onClick: onClose, children: "Close" })] }));
+    }
+}));
+describe('TaskforceWidget Component', () => {
+    const user = userEvent.setup();
+    it('6.1 & 6.2 Renders floating button with badge count', async () => {
+        render(_jsx(TaskforceWidget, {}));
+        const button = screen.getByTitle(/Taskforce/i);
+        expect(button).toBeInTheDocument();
+        // Mock core reports 3 tasks
+        await waitFor(() => {
+            expect(screen.getByText('3')).toBeInTheDocument(); // Badge
+        });
+    });
+    it('6.3 & 6.4 Toggles modal on click', async () => {
+        render(_jsx(TaskforceWidget, {}));
+        const button = screen.getByTitle(/Taskforce/i);
+        // Initially hidden (display: none)
+        const root = document.getElementById('taskforce-root');
+        expect(root).toHaveStyle({ display: 'none' });
+        // Open
+        await user.click(button);
+        expect(root).toHaveStyle({ display: 'flex' });
+        // Close via internal button (passed to onClose)
+        const closeBtn = screen.getByText('Close');
+        await user.click(closeBtn);
+        expect(root).toHaveStyle({ display: 'none' });
+    });
+    it('6.6 Toggles modal on Alt+T keyboard shortcut', async () => {
+        render(_jsx(TaskforceWidget, {}));
+        const root = document.getElementById('taskforce-root');
+        // Alt+T
+        fireEvent.keyDown(window, { key: 't', altKey: true });
+        expect(root).toHaveStyle({ display: 'flex' });
+        // Alt+T again
+        fireEvent.keyDown(window, { key: 't', altKey: true });
+        expect(root).toHaveStyle({ display: 'none' });
+    });
+    it('6.9 State persistence: Core remains mounted when closed', async () => {
+        render(_jsx(TaskforceWidget, {}));
+        // It's always mounted
+        expect(screen.getByTestId('core-component')).toBeInTheDocument();
+        // Toggle open
+        fireEvent.keyDown(window, { key: 't', altKey: true });
+        // Use waitFor because of potential state updates
+        await waitFor(() => {
+            expect(screen.getByTestId('core-component')).toBeInTheDocument();
+        });
+        // Toggle closed
+        fireEvent.keyDown(window, { key: 't', altKey: true });
+        const root = document.getElementById('taskforce-root');
+        expect(root).toHaveStyle({ display: 'none' });
+        // Component is still in DOM (preserves state)
+        expect(screen.getByTestId('core-component')).toBeInTheDocument();
+    });
+    it('Locks body scroll when open and unlocks when closed', async () => {
+        render(_jsx(TaskforceWidget, {}));
+        const button = screen.getByTitle(/Taskforce/i);
+        // Initial state
+        expect(document.body.style.overflow).toBe('');
+        // Open
+        await user.click(button);
+        expect(document.body.style.overflow).toBe('hidden');
+        // Close
+        const closeBtn = screen.getByText('Close');
+        await user.click(closeBtn);
+        expect(document.body.style.overflow).toBe('');
+    });
+    it('Draggable: handles mouse down on header', () => {
+        render(_jsx(TaskforceWidget, {}));
+        const header = screen.getByTestId('header');
+        fireEvent.mouseDown(header, { clientX: 100, clientY: 100 });
+        fireEvent.mouseMove(window, { clientX: 150, clientY: 150 });
+        fireEvent.mouseUp(window);
+        const modal = screen.getByTestId('core-component').parentElement;
+        expect(modal).toBeInTheDocument();
+    });
+});

package/dist/UnsavedChangesRelaxed.test.d.ts

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

package/dist/UnsavedChangesRelaxed.test.js

@@ -0,0 +1,16 @@
+import fs from 'fs';
+import path from 'path';
+import { describe, it, expect } from 'vitest';
+describe('Unsaved Changes Dialog Contract', () => {
+    const standaloneLayoutPath = path.resolve(__dirname, 'components/views/StandaloneLayout.tsx');
+    const source = fs.readFileSync(standaloneLayoutPath, 'utf-8');
+    it('includes the unsaved changes modal title and message', () => {
+        expect(source).toContain('Unsaved Changes');
+        expect(source).toContain('You have unsaved changes. Would you like to save them?');
+    });
+    it('includes explicit action labels for close, discard, and save', () => {
+        expect(source).toContain('Close dialog and continue editing');
+        expect(source).toContain('Discard unsaved changes and leave');
+        expect(source).toContain('Save changes and leave');
+    });
+});

package/dist/__tests__/localizationCatalogs.test.d.ts

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

package/dist/__tests__/localizationCatalogs.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { enUS } from '../localization/locales/en-US';
+import { es419 } from '../localization/locales/es-419';
+import { ptBR } from '../localization/locales/pt-BR';
+function collectLeafKeys(input, prefix = '') {
+    if (!input || typeof input !== 'object')
+        return [];
+    return Object.entries(input).flatMap(([key, value]) => {
+        const nextPrefix = prefix ? `${prefix}.${key}` : key;
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            return collectLeafKeys(value, nextPrefix);
+        }
+        return [nextPrefix];
+    });
+}
+describe('Localization catalogs', () => {
+    it('keeps identical key coverage across locales', () => {
+        const enKeys = collectLeafKeys(enUS).sort();
+        const esKeys = collectLeafKeys(es419).sort();
+        const ptKeys = collectLeafKeys(ptBR).sort();
+        expect(esKeys).toEqual(enKeys);
+        expect(ptKeys).toEqual(enKeys);
+    });
+    it('avoids blank translations in non-default locales', () => {
+        const values = [es419, ptBR];
+        for (const catalog of values) {
+            for (const key of collectLeafKeys(catalog)) {
+                const segments = key.split('.');
+                let cursor = catalog;
+                for (const segment of segments)
+                    cursor = cursor?.[segment];
+                expect(typeof cursor).toBe('string');
+                expect(String(cursor).trim().length).toBeGreaterThan(0);
+            }
+        }
+    });
+});

package/dist/__tests__/planParser.test.d.ts

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

package/dist/__tests__/planParser.test.js

@@ -0,0 +1,183 @@
+import { describe, it, expect } from 'vitest';
+import { parsePlan, flattenSelected } from '../utils/planParser';
+// ─── parsePlan ───────────────────────────────────────────────────────────────
+describe('parsePlan', () => {
+    it('returns empty array for empty content', () => {
+        expect(parsePlan('')).toEqual([]);
+        expect(parsePlan('   \n\n   ')).toEqual([]);
+    });
+    it('parses H2 headings as top-level root tasks', () => {
+        const result = parsePlan('## Phase 1\n## Phase 2');
+        expect(result).toHaveLength(2);
+        expect(result[0].title).toBe('Phase 1');
+        expect(result[1].title).toBe('Phase 2');
+        expect(result[0].depth).toBe(0);
+    });
+    it('parses H3 headings as children of the preceding H2', () => {
+        const md = `## Phase 1\n### Setup\n### Config`;
+        const result = parsePlan(md);
+        expect(result).toHaveLength(1);
+        expect(result[0].children).toHaveLength(2);
+        expect(result[0].children[0].title).toBe('Setup');
+        expect(result[0].children[0].depth).toBe(1);
+    });
+    it('parses dash list items as children of current heading', () => {
+        const md = `## Phase 1\n- Task A\n- Task B`;
+        const result = parsePlan(md);
+        expect(result[0].children).toHaveLength(2);
+        expect(result[0].children[0].title).toBe('Task A');
+    });
+    it('parses asterisk list items', () => {
+        const md = `## Phase 1\n* Task A\n* Task B`;
+        const result = parsePlan(md);
+        expect(result[0].children).toHaveLength(2);
+    });
+    it('parses numbered list items', () => {
+        const md = `## Phase 1\n1. Task A\n2. Task B`;
+        const result = parsePlan(md);
+        expect(result[0].children).toHaveLength(2);
+        expect(result[0].children[0].title).toBe('Task A');
+    });
+    it('nests list items under H3 when H3 is present', () => {
+        const md = `## Phase 1\n### API\n- Route A\n- Route B\n### UI\n- Component X`;
+        const result = parsePlan(md);
+        const phase = result[0];
+        expect(phase.children).toHaveLength(2); // API, UI
+        expect(phase.children[0].children).toHaveLength(2); // Route A, Route B
+        expect(phase.children[1].children).toHaveLength(1); // Component X
+    });
+    it('all nodes start selected by default', () => {
+        const md = `## Phase 1\n### Step\n- Item`;
+        const result = parsePlan(md);
+        expect(result[0].selected).toBe(true);
+        expect(result[0].children[0].selected).toBe(true);
+        expect(result[0].children[0].children[0].selected).toBe(true);
+    });
+    it('generates stable idempotency keys', () => {
+        const md = `## Phase 1\n- Task A`;
+        const r1 = parsePlan(md);
+        const r2 = parsePlan(md);
+        expect(r1[0].idempotencyKey).toBe(r2[0].idempotencyKey);
+        expect(r1[0].children[0].idempotencyKey).toBe(r2[0].children[0].idempotencyKey);
+    });
+    it('sibling tasks have different idempotency keys', () => {
+        const md = `## Phase 1\n- Task A\n- Task B`;
+        const result = parsePlan(md);
+        const keys = result[0].children.map((c) => c.idempotencyKey);
+        expect(new Set(keys).size).toBe(keys.length);
+    });
+});
+// ─── Type inference ──────────────────────────────────────────────────────────
+describe('parsePlan — type inference', () => {
+    function typeOf(title) {
+        return parsePlan(`## ${title}`)[0].type;
+    }
+    it('infers "bug" for fix/bug keywords', () => {
+        expect(typeOf('Fix login bug')).toBe('bug');
+        expect(typeOf('Bug: broken redirect')).toBe('bug');
+        expect(typeOf('Hotfix for session issue')).toBe('bug');
+    });
+    it('infers "refactor" for refactor/cleanup keywords', () => {
+        expect(typeOf('Refactor auth module')).toBe('refactor');
+        expect(typeOf('Clean up legacy routes')).toBe('refactor');
+    });
+    it('infers "documentation" for docs keywords', () => {
+        expect(typeOf('Update README')).toBe('documentation');
+        expect(typeOf('Write docs for API')).toBe('documentation');
+    });
+    it('infers "chore" for setup/config/deploy keywords', () => {
+        expect(typeOf('Setup CI pipeline')).toBe('chore');
+        expect(typeOf('Config environment')).toBe('chore');
+        expect(typeOf('Deploy infrastructure')).toBe('chore');
+    });
+    it('defaults to "feature" for unrecognised titles', () => {
+        expect(typeOf('Add user dashboard')).toBe('feature');
+        expect(typeOf('Phase 1 — Core Module')).toBe('feature');
+    });
+});
+// ─── Priority inference ──────────────────────────────────────────────────────
+describe('parsePlan — priority inference', () => {
+    function priorityOf(title) {
+        return parsePlan(`## ${title}`)[0].priority;
+    }
+    it('infers priority 4 (Critical) for "critical" / "blocker" / "p0"', () => {
+        expect(priorityOf('Critical: auth bypass')).toBe(4);
+        expect(priorityOf('Blocker — build fails')).toBe(4);
+        expect(priorityOf('P0 fix needed')).toBe(4);
+    });
+    it('infers priority 3 (High) for "high" / "important"', () => {
+        expect(priorityOf('High priority task')).toBe(3);
+        expect(priorityOf('Important migration')).toBe(3);
+    });
+    it('infers priority 1 (Low) for "low" / "minor" / "nice-to-have"', () => {
+        expect(priorityOf('Low priority cleanup')).toBe(1);
+        expect(priorityOf('Minor styling tweak')).toBe(1);
+        expect(priorityOf('Nice to have feature')).toBe(1);
+    });
+    it('defaults to priority 2 (Medium) for unrecognised titles', () => {
+        expect(priorityOf('Add user dashboard')).toBe(2);
+    });
+});
+// ─── flattenSelected ─────────────────────────────────────────────────────────
+describe('flattenSelected', () => {
+    it('returns all nodes when all selected', () => {
+        const md = `## Phase\n### Step\n- Item`;
+        const tasks = parsePlan(md);
+        const flat = flattenSelected(tasks);
+        expect(flat.length).toBe(3);
+    });
+    it('excludes deselected nodes and their children', () => {
+        const md = `## Phase\n### Step\n- Item`;
+        const tasks = parsePlan(md);
+        // Deselect the H3 — should exclude it and its children
+        tasks[0].children[0].selected = false;
+        const flat = flattenSelected(tasks);
+        // Should only have the H2 root
+        expect(flat.length).toBe(1);
+        expect(flat[0].title).toBe('Phase');
+    });
+    it('returns empty array when root is deselected', () => {
+        const md = `## Phase\n- Item`;
+        const tasks = parsePlan(md);
+        tasks[0].selected = false;
+        const flat = flattenSelected(tasks);
+        expect(flat).toHaveLength(0);
+    });
+    it('preserves order (root before children)', () => {
+        const md = `## Phase 1\n- Task A\n- Task B\n## Phase 2\n- Task C`;
+        const tasks = parsePlan(md);
+        const flat = flattenSelected(tasks);
+        expect(flat[0].title).toBe('Phase 1');
+        expect(flat[1].title).toBe('Task A');
+        expect(flat[2].title).toBe('Task B');
+        expect(flat[3].title).toBe('Phase 2');
+        expect(flat[4].title).toBe('Task C');
+    });
+});
+// ─── Edge cases ──────────────────────────────────────────────────────────────
+describe('parsePlan — edge cases', () => {
+    it('handles H3 without preceding H2 as root node', () => {
+        const result = parsePlan('### Orphan step');
+        expect(result).toHaveLength(1);
+        expect(result[0].title).toBe('Orphan step');
+    });
+    it('handles documents with no headings (only paragraphs)', () => {
+        const result = parsePlan('This is just a paragraph.\nAnd another one.');
+        // No actionable tasks parseable
+        expect(result).toHaveLength(0);
+    });
+    it('trims trailing/leading whitespace from titles', () => {
+        const result = parsePlan('##   Phase 1   ');
+        expect(result[0].title).toBe('Phase 1');
+    });
+    it('handles mixed list markers in the same section', () => {
+        const md = `## Phase\n- Task A\n* Task B\n1. Task C`;
+        const result = parsePlan(md);
+        expect(result[0].children).toHaveLength(3);
+    });
+    it('ignores horizontal rules and other non-task lines', () => {
+        const md = `## Phase 1\n---\n- Task A`;
+        const result = parsePlan(md);
+        expect(result[0].children).toHaveLength(1);
+    });
+});

package/dist/__tests__/releaseVersion.test.d.ts

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

package/dist/__tests__/releaseVersion.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+// @ts-expect-error - JS module without generated .d.ts (validated by tests).
+import { computeNextPatch, computeNextVersion } from '../../scripts/release-version-lib.mjs';
+describe('release version automation', () => {
+    it('increments patch from latest matching tag', () => {
+        const next = computeNextVersion({
+            major: 1,
+            minor: 4,
+            releaseTags: ['v1.4.7', 'v1.4.8', 'v1.3.9'],
+            currentPackageVersion: '1.4.8'
+        });
+        expect(next).toBe('1.4.9');
+    });
+    it('uses package patch + 1 when no tags exist for configured line', () => {
+        const nextPatch = computeNextPatch({
+            major: 0,
+            minor: 3,
+            releaseTags: [],
+            currentPackageVersion: '0.3.13-beta.2'
+        });
+        expect(nextPatch).toBe(14);
+    });
+    it('starts new major/minor line at patch 0 when no tags exist', () => {
+        const next = computeNextVersion({
+            major: 2,
+            minor: 0,
+            releaseTags: ['v1.9.9'],
+            currentPackageVersion: '1.9.9'
+        });
+        expect(next).toBe('2.0.0');
+    });
+});

package/dist/__tests__/structuredCommentValidation.test.d.ts

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

package/dist/__tests__/structuredCommentValidation.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { validateStructuredCommentForAdd } from '../mcp/structuredCommentValidation';
+describe('structured comment add validation', () => {
+    it('passes ordinary comments', () => {
+        const result = validateStructuredCommentForAdd('LGTM. Proceeding with implementation.');
+        expect(result).toEqual({ ok: true });
+    });
+    it('passes complete evaluation summary comments', () => {
+        const comment = [
+            '## Evaluation Summary',
+            '### Recommendation (Proceed | Pivot | Kill)',
+            'Proceed',
+            '### Value Score (1-5)',
+            '4',
+            '### Risk Score (1-5)',
+            '2',
+            '### Next Step',
+            'Start implementation.'
+        ].join('\n');
+        expect(validateStructuredCommentForAdd(comment)).toEqual({ ok: true });
+    });
+    it('fails incomplete review summary comments', () => {
+        const comment = ['## Review Summary', '### Findings', '- Missing tests'].join('\n');
+        const result = validateStructuredCommentForAdd(comment);
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.message).toContain('### Verdict (PASS | WARN | FAIL)');
+            expect(result.message).toContain('### Next Status');
+        }
+    });
+});

package/dist/__tests__/structuredDocValidation.test.d.ts

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