@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/core/InitiativeTemplates.test.js

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { TaskforceCore } from './Taskforce';
-function makeTempProjectRoot() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-initiative-'));
-}
-describe('TaskforceCore initiative templates', () => {
-    it('returns launch/migration/incident templates', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const templates = core.getInitiativeTemplates();
-        expect(templates.map(t => t.id)).toEqual(expect.arrayContaining(['launch', 'migration', 'incident']));
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('creates initiative and milestone children from template', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const created = core.createInitiativeFromTemplate({
-            templateId: 'launch',
-            title: 'My Launch'
-        });
-        expect(created.initiative.id).toBeTruthy();
-        expect(created.milestones.length).toBeGreaterThan(0);
-        expect(created.milestones.every(m => m.parentTaskId === created.initiative.id)).toBe(true);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-    it('clones checklist blocks to direct children in one action', () => {
-        const projectRoot = makeTempProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const parent = core.createTask({ title: 'Parent' });
-        const childA = core.createTask({ title: 'Child A', parentTaskId: parent.id });
-        core.createTask({ title: 'Child B', parentTaskId: parent.id });
-        core.createTask({ title: 'Other Parent Child', parentTaskId: childA.id });
-        const result = core.cloneChecklistBlocksToChildren({
-            parentTaskId: parent.id,
-            checklistBlocks: {
-                definitionOfDone: ['Done A'],
-                rollbackPlan: ['Rollback A']
-            }
-        });
-        expect(result.updated).toBe(2);
-        expect(result.children.length).toBe(2);
-        core.close();
-        fs.rmSync(projectRoot, { recursive: true, force: true });
-    });
-});

package/dist/core/ParentLifecycle.test.js

@@ -1,98 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { TaskforceCore } from './Taskforce';
-const roots = [];
-function createCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-parent-lifecycle-'));
-    roots.push(projectRoot);
-    return new TaskforceCore({ projectRoot });
-}
-afterEach(() => {
-    while (roots.length > 0) {
-        const root = roots.pop();
-        if (root)
-            fs.rmSync(root, { recursive: true, force: true });
-    }
-});
-describe('TaskforceCore parent lifecycle', () => {
-    it('auto-completes parent chain when all descendants are terminal', () => {
-        const core = createCore();
-        const parent = core.createTask({ title: 'Parent', status: 'task' });
-        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
-        const grandchild = core.createTask({ title: 'Grandchild', parentTaskId: child.id, status: 'task' });
-        const updatedGrandchild = core.updateTask(grandchild.id, { status: 'done' });
-        const updatedChild = core.getTask(child.id);
-        const updatedParent = core.getTask(parent.id);
-        expect(updatedGrandchild?.status).toBe('done');
-        expect(updatedChild?.status).toBe('done');
-        expect(updatedParent?.status).toBe('done');
-        core.close();
-    });
-    it('keeps parent open when any descendant remains open', () => {
-        const core = createCore();
-        const parent = core.createTask({ title: 'Parent', status: 'task' });
-        const doneChild = core.createTask({ title: 'Done Child', parentTaskId: parent.id, status: 'done' });
-        const openChild = core.createTask({ title: 'Open Child', parentTaskId: parent.id, status: 'task' });
-        const refreshedParent = core.getTask(parent.id);
-        expect(doneChild.status).toBe('done');
-        expect(openChild.status).toBe('task');
-        expect(refreshedParent?.status).toBe('task');
-        core.close();
-    });
-    it('reopens done parent when a new open descendant is added', () => {
-        const core = createCore();
-        const parent = core.createTask({ title: 'Parent', status: 'task' });
-        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
-        core.updateTask(child.id, { status: 'done' });
-        expect(core.getTask(parent.id)?.status).toBe('done');
-        core.createTask({ title: 'New Child', parentTaskId: parent.id, status: 'task' });
-        expect(core.getTask(parent.id)?.status).toBe('task');
-        core.close();
-    });
-    it('does not reopen cancelled parent when open descendant is added', () => {
-        const core = createCore();
-        const parent = core.createTask({ title: 'Parent', status: 'task' });
-        core.updateTask(parent.id, { status: 'cancelled' });
-        core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
-        expect(core.getTask(parent.id)?.status).toBe('cancelled');
-        core.close();
-    });
-    it('blocks manual done on parent tasks', () => {
-        const core = createCore();
-        const parent = core.createTask({ title: 'Parent', status: 'task' });
-        core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
-        expect(() => core.updateTask(parent.id, { status: 'done' })).toThrow(/Parent tasks cannot be marked done manually/);
-        core.close();
-    });
-    it('cancels open descendants in cascade mode', () => {
-        const core = createCore();
-        const parent = core.createTask({ title: 'Parent', status: 'task' });
-        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
-        const grandchild = core.createTask({ title: 'Grandchild', parentTaskId: child.id, status: 'task' });
-        const cancelledParent = core.cancelParentWithOpenDescendants(parent.id, { mode: 'cascade', reason: 'No longer needed' });
-        const refreshedChild = core.getTask(child.id);
-        const refreshedGrandchild = core.getTask(grandchild.id);
-        expect(cancelledParent?.status).toBe('cancelled');
-        expect(cancelledParent?.canceledReason).toBe('No longer needed');
-        expect(refreshedChild?.status).toBe('cancelled');
-        expect(refreshedGrandchild?.status).toBe('cancelled');
-        core.close();
-    });
-    it('unlinks open descendants in unlink mode and cancels only parent', () => {
-        const core = createCore();
-        const parent = core.createTask({ title: 'Parent', status: 'task' });
-        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
-        const grandchild = core.createTask({ title: 'Grandchild', parentTaskId: child.id, status: 'task' });
-        const cancelledParent = core.cancelParentWithOpenDescendants(parent.id, { mode: 'unlink', reason: 'No longer needed' });
-        const refreshedChild = core.getTask(child.id);
-        const refreshedGrandchild = core.getTask(grandchild.id);
-        expect(cancelledParent?.status).toBe('cancelled');
-        expect(refreshedChild?.status).toBe('task');
-        expect(refreshedGrandchild?.status).toBe('task');
-        expect(refreshedChild?.parentTaskId).toBeNull();
-        expect(refreshedGrandchild?.parentTaskId).toBeNull();
-        core.close();
-    });
-});

package/dist/migrations/clientMigrations.d.ts

@@ -1,9 +0,0 @@
-import type { CategoryConfig, TaskItem } from '../types';
-export declare function normalizeTaskFromApi(task: any, options?: {
-    mapLegacyTodoStatus?: boolean;
-}): TaskItem;
-export declare function migrateCategoryFilterLabels(filterCategories: string[], activeCategories: CategoryConfig[]): string[];
-export declare function normalizePriorityFilterValues(filterPriorities: Array<string | number>, priorities: Array<{
-    value: number;
-}>): number[];
-export declare function matchesPriorityFilter(taskPriority: string | number | null | undefined, filterPriorities: Array<string | number>): boolean;

package/dist/migrations/clientMigrations.js

@@ -1,74 +0,0 @@
-import { PRIORITY_LOGIC } from '../compat/priorityCompat';
-import { MIGRATION_COMPAT_ENABLED } from './flags.js';
-export function normalizeTaskFromApi(task, options) {
-    // COMPAT_REMOVE_AFTER: v1.0.0
-    // COMPAT_TRACK: legacy-status-todo
-    const mapLegacyTodoStatus = MIGRATION_COMPAT_ENABLED && (options?.mapLegacyTodoStatus ?? false);
-    return {
-        ...task,
-        assignee: (() => {
-            const normalized = String(task.assignee || '').trim().toLowerCase();
-            if (normalized === 'agent' || normalized === 'ai')
-                return 'agent';
-            if (normalized === 'user')
-                return 'user';
-            if (normalized === 'unassigned')
-                return 'unassigned';
-            return 'unassigned';
-        })(),
-        category: typeof task.category === 'string' ? task.category : task.category?.value || 'default',
-        type: (typeof task.type === 'string' ? task.type : task.type?.label || 'feature').toLowerCase(),
-        priority: typeof task.priority === 'number' ? task.priority : (PRIORITY_LOGIC[task.priority] ?? 2),
-        complexity: typeof task.complexity === 'number' ? task.complexity : 3,
-        parentTaskId: typeof task.parentTaskId === 'string' && task.parentTaskId.trim().length > 0 ? task.parentTaskId.trim() : null,
-        ...(() => {
-            const normalizedStatus = task.status === 'blocked' || task.status === 'on hold'
-                ? 'on-hold'
-                : task.status;
-            if (mapLegacyTodoStatus) {
-                return { status: normalizedStatus === 'todo' ? 'task' : normalizedStatus };
-            }
-            return { status: normalizedStatus };
-        })()
-    };
-}
-export function migrateCategoryFilterLabels(filterCategories, activeCategories) {
-    // COMPAT_REMOVE_AFTER: v1.0.0
-    // COMPAT_TRACK: category-label-filter-migration
-    if (!MIGRATION_COMPAT_ENABLED)
-        return filterCategories;
-    if (!filterCategories.length || !activeCategories.length)
-        return filterCategories;
-    return Array.from(new Set(filterCategories.map(filterValue => {
-        const matched = activeCategories.find(category => category.label === filterValue);
-        return matched ? matched.value : filterValue;
-    })));
-}
-export function normalizePriorityFilterValues(filterPriorities, priorities) {
-    if (!priorities.length || !filterPriorities.length)
-        return [];
-    const available = new Set(priorities.map(p => Number(p.value)));
-    const targetIsOneToFive = available.has(5) && !available.has(0);
-    const targetIsOneToFour = available.has(4) && !available.has(5) && !available.has(0);
-    const rawNumeric = filterPriorities
-        .map(p => Number(p))
-        .filter(n => Number.isFinite(n));
-    // COMPAT_REMOVE_AFTER: v1.0.0
-    // COMPAT_TRACK: priority-scale-0-to-4
-    const shouldShiftLegacyScale = MIGRATION_COMPAT_ENABLED && targetIsOneToFive && rawNumeric.includes(0);
-    // COMPAT_REMOVE_AFTER: v1.0.0
-    // COMPAT_TRACK: priority-on-hold-to-status
-    const shouldConvertOldFiveScale = MIGRATION_COMPAT_ENABLED && targetIsOneToFour && rawNumeric.includes(5);
-    return Array.from(new Set(rawNumeric
-        .map(n => {
-        if (shouldShiftLegacyScale && n >= 0 && n <= 4)
-            return n + 1;
-        if (shouldConvertOldFiveScale && n >= 2 && n <= 5)
-            return n - 1;
-        return n;
-    })
-        .filter(n => available.has(n))));
-}
-export function matchesPriorityFilter(taskPriority, filterPriorities) {
-    return filterPriorities.some(filterPriority => String(filterPriority) === String(taskPriority));
-}

package/dist/migrations/flags.d.ts

@@ -1,6 +0,0 @@
-/**
- * Single switch for backward-compatibility and migration behavior.
- *
- * Set to false when preparing the post-compat release.
- */
-export declare const MIGRATION_COMPAT_ENABLED = true;

package/dist/migrations/flags.js

@@ -1,8 +0,0 @@
-// COMPAT_REMOVE_AFTER: v1.0.0
-// COMPAT_TRACK: global-migration-flag
-/**
- * Single switch for backward-compatibility and migration behavior.
- *
- * Set to false when preparing the post-compat release.
- */
-export const MIGRATION_COMPAT_ENABLED = true;

package/dist/migrations/taskMigrations.d.ts

@@ -1,71 +0,0 @@
-import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
-export interface PriorityDefinition {
-    value: number;
-    label: string;
-    color?: string;
-    icon?: string;
-}
-export interface TaskMigrationComment {
-    id: string;
-    text: string;
-    author: 'user' | 'ai';
-    timestamp: string;
-}
-export interface TaskMigrationScreenshot {
-    path: string;
-    fsPath?: string;
-    caption?: string;
-    timestamp?: string;
-}
-export interface TaskMigrationItem {
-    id: string;
-    title: string;
-    description?: string | null;
-    status: string;
-    priority?: number | string;
-    complexity?: number | string;
-    type?: string;
-    category?: string;
-    approach?: string;
-    createdAt?: string;
-    updatedAt?: string;
-    completedAt?: string | null;
-    scheduledDate?: string | null;
-    dueDate?: string | null;
-    scheduledWeekKey?: string | null;
-    orderInDay?: number | null;
-    canceledReason?: string;
-    isArchived?: boolean;
-    specialists?: string[];
-    taxonomies?: Record<string, string | string[]>;
-    createdBy?: string;
-    comments?: TaskMigrationComment[];
-    screenshots?: Array<string | TaskMigrationScreenshot>;
-}
-export declare function normalizePriorityValue(priority: unknown, legacyScale?: boolean): number;
-export declare function normalizePriorityDefinitions(priorities: PriorityDefinition[]): {
-    priorities: PriorityDefinition[];
-    changed: boolean;
-};
-export declare function migratePriorityScaleIfNeeded(args: {
-    db: DatabaseAdapter;
-    tenantId: string;
-    readConfig: () => {
-        priorities?: PriorityDefinition[];
-    } | undefined;
-    writeConfig: (config: any) => void;
-}): void;
-export declare function migrateOnHoldPriorityToStatusIfNeeded(args: {
-    db: DatabaseAdapter;
-    tenantId: string;
-    readConfig: () => {
-        priorities?: PriorityDefinition[];
-    } | undefined;
-    writeConfig: (config: any) => void;
-}): void;
-export declare function performLegacyTaskFileMigrationIfNeeded(args: {
-    db: DatabaseAdapter;
-    basePath: string;
-    tenantId: string;
-    normalizePriority: (priority: unknown, legacyScale?: boolean) => number;
-}): void;

package/dist/migrations/taskMigrations.js

@@ -1,236 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { MIGRATION_COMPAT_ENABLED } from './flags.js';
-const DEFAULT_PRIORITY_DEFINITIONS = [
-    { value: 1, label: 'Low', color: 'teal-500', icon: 'ArrowDown' },
-    { value: 2, label: 'Medium', color: 'blue-500', icon: 'Minus' },
-    { value: 3, label: 'High', color: 'amber-500', icon: 'ArrowUp' },
-    { value: 4, label: 'Critical', color: 'red-500', icon: 'AlertTriangle' },
-];
-function normalizeStatusValue(status) {
-    const normalized = String(status || '').trim().toLowerCase();
-    if (normalized === 'blocked' || normalized === 'on hold' || normalized === 'on-hold')
-        return 'on-hold';
-    if (normalized === 'task' || normalized === 'in-progress' || normalized === 'review' || normalized === 'done' || normalized === 'cancelled') {
-        return normalized;
-    }
-    return 'task';
-}
-export function normalizePriorityValue(priority, legacyScale = false) {
-    const numeric = typeof priority === 'number' ? priority : Number(priority);
-    if (!Number.isFinite(numeric))
-        return 2;
-    const rounded = Math.round(numeric);
-    // COMPAT_REMOVE_AFTER: v1.0.0
-    // COMPAT_TRACK: priority-scale-0-to-4
-    if (MIGRATION_COMPAT_ENABLED && legacyScale && rounded >= 0 && rounded <= 4) {
-        return Math.max(1, Math.min(4, rounded + 1));
-    }
-    return Math.max(1, Math.min(4, rounded));
-}
-export function normalizePriorityDefinitions(priorities) {
-    if (!Array.isArray(priorities) || priorities.length === 0) {
-        return { priorities: DEFAULT_PRIORITY_DEFINITIONS.map(p => ({ ...p })), changed: true };
-    }
-    const hasLegacyScale = priorities.some(p => Number(p.value) === 0);
-    let changed = false;
-    const byValue = new Map();
-    for (const p of priorities) {
-        const nextValue = normalizePriorityValue(p.value, hasLegacyScale);
-        if (nextValue !== p.value)
-            changed = true;
-        if (byValue.has(nextValue)) {
-            changed = true;
-            continue;
-        }
-        byValue.set(nextValue, { ...p, value: nextValue });
-    }
-    for (const fallback of DEFAULT_PRIORITY_DEFINITIONS) {
-        if (!byValue.has(fallback.value)) {
-            byValue.set(fallback.value, { ...fallback });
-            changed = true;
-        }
-    }
-    const normalized = Array.from(byValue.values()).sort((a, b) => a.value - b.value);
-    return { priorities: normalized, changed };
-}
-export function migratePriorityScaleIfNeeded(args) {
-    // COMPAT_REMOVE_AFTER: v1.0.0
-    // COMPAT_TRACK: priority-scale-0-to-4
-    if (!MIGRATION_COMPAT_ENABLED)
-        return;
-    const { db, tenantId, readConfig, writeConfig } = args;
-    const hasLegacyTaskPriorities = !!db.prepare('SELECT 1 FROM tasks WHERE tenant_id = ? AND priority = 0 LIMIT 1').get(tenantId);
-    if (hasLegacyTaskPriorities) {
-        db.prepare('UPDATE tasks SET priority = priority + 1 WHERE tenant_id = ? AND priority >= 0 AND priority <= 4').run(tenantId);
-    }
-    const config = readConfig() || {};
-    if (Array.isArray(config.priorities)) {
-        const normalized = normalizePriorityDefinitions(config.priorities);
-        if (normalized.changed) {
-            config.priorities = normalized.priorities;
-            writeConfig(config);
-        }
-    }
-}
-function isOnHoldPriorityLabel(label) {
-    const normalized = String(label || '').trim().toLowerCase();
-    return normalized === 'on hold' || normalized === 'on-hold';
-}
-export function migrateOnHoldPriorityToStatusIfNeeded(args) {
-    // COMPAT_REMOVE_AFTER: v1.0.0
-    // COMPAT_TRACK: priority-on-hold-to-status
-    if (!MIGRATION_COMPAT_ENABLED)
-        return;
-    const { db, tenantId, readConfig, writeConfig } = args;
-    const hasLegacyFiveScale = !!db.prepare('SELECT 1 FROM tasks WHERE tenant_id = ? AND priority = 5 LIMIT 1').get(tenantId);
-    const config = readConfig() || {};
-    const hasConfigOnHold = Array.isArray(config.priorities)
-        && config.priorities.some((p) => Number(p.value) === 1 && isOnHoldPriorityLabel(p.label));
-    const hasConfigFiveScale = Array.isArray(config.priorities)
-        && config.priorities.some((p) => Number(p.value) === 5);
-    // Guard: do not infer legacy "on-hold" from tasks with priority=1, because 1 is now valid "Low".
-    const shouldMigrateDb = hasLegacyFiveScale || hasConfigOnHold || hasConfigFiveScale;
-    if (!shouldMigrateDb)
-        return;
-    if (hasConfigOnHold) {
-        db.prepare("UPDATE tasks SET status = 'on-hold' WHERE tenant_id = ? AND priority = 1 AND status IN ('task', 'in-progress', 'review')").run(tenantId);
-    }
-    if (hasLegacyFiveScale || hasConfigOnHold || hasConfigFiveScale) {
-        db.prepare('UPDATE tasks SET priority = priority - 1 WHERE tenant_id = ? AND priority >= 2 AND priority <= 5').run(tenantId);
-        db.prepare('UPDATE tasks SET priority = 1 WHERE tenant_id = ? AND priority < 1').run(tenantId);
-        db.prepare('UPDATE tasks SET priority = 4 WHERE tenant_id = ? AND priority > 4').run(tenantId);
-    }
-    if (!Array.isArray(config.priorities))
-        return;
-    const transformed = config.priorities
-        .filter((p) => !(Number(p.value) === 1 && isOnHoldPriorityLabel(p.label)))
-        .map((p) => {
-        const value = Number(p.value);
-        const nextValue = value >= 2 && value <= 5 ? value - 1 : value;
-        return { ...p, value: normalizePriorityValue(nextValue, false) };
-    })
-        .sort((a, b) => a.value - b.value);
-    config.priorities = transformed;
-    writeConfig(config);
-}
-export function performLegacyTaskFileMigrationIfNeeded(args) {
-    // COMPAT_REMOVE_AFTER: v1.0.0
-    // COMPAT_TRACK: legacy-task-files-to-sqlite
-    if (!MIGRATION_COMPAT_ENABLED)
-        return;
-    const { db, basePath, tenantId, normalizePriority } = args;
-    const count = db.prepare('SELECT count(*) as count FROM tasks WHERE tenant_id = ?').get(tenantId);
-    if (count.count > 0)
-        return;
-    const taskFile = path.resolve(basePath, 'tasks.json');
-    const tasksToMigrate = [];
-    if (fs.existsSync(taskFile)) {
-        try {
-            const data = JSON.parse(fs.readFileSync(taskFile, 'utf-8'));
-            if (data.tasks)
-                tasksToMigrate.push(...data.tasks);
-            if (data.archived)
-                tasksToMigrate.push(...data.archived);
-        }
-        catch (e) {
-            console.error('[Taskforce] Failed to read tasks.json for migration', e);
-        }
-    }
-    if (tasksToMigrate.length === 0)
-        return;
-    console.log(`[Taskforce] Migrating ${tasksToMigrate.length} tasks to SQLite...`);
-    const hasLegacyPriorityScale = tasksToMigrate.some(task => Number(task.priority) === 0);
-    const insertTask = db.prepare(`
-        INSERT OR REPLACE INTO tasks (
-            id, tenant_id, title, description, status, priority, complexity, type, category,
-            approach, created_at, updated_at, completed_at, canceled_reason,
-            scheduled_date, due_date, scheduled_week_key, order_in_day,
-            is_archived, specialists, taxonomies, created_by
-        ) VALUES (
-            @id, @tenant_id, @title, @description, @status, @priority, @complexity, @type, @category,
-            @approach, @created_at, @updated_at, @completed_at, @canceled_reason,
-            @scheduled_date, @due_date, @scheduled_week_key, @order_in_day,
-            @is_archived, @specialists, @taxonomies, @created_by
-        )
-    `);
-    const insertComment = db.prepare(`
-        INSERT OR REPLACE INTO comments (id, tenant_id, task_id, text, author, timestamp)
-        VALUES (@id, @tenant_id, @task_id, @text, @author, @timestamp)
-    `);
-    const insertScreenshot = db.prepare(`
-        INSERT OR REPLACE INTO screenshots (id, tenant_id, task_id, path, fs_path, caption, timestamp)
-        VALUES (@id, @tenant_id, @task_id, @path, @fs_path, @caption, @timestamp)
-    `);
-    const transaction = db.transaction((tasks) => {
-        for (const task of tasks) {
-            const isArchived = task.isArchived !== undefined
-                ? (task.isArchived ? 1 : 0)
-                : (task.status === 'done' || task.status === 'cancelled' ? 1 : 0);
-            insertTask.run({
-                id: task.id,
-                tenant_id: tenantId,
-                title: task.title,
-                description: task.description || null,
-                status: normalizeStatusValue(task.status),
-                priority: normalizePriority(task.priority, hasLegacyPriorityScale),
-                complexity: typeof task.complexity === 'string' ? 3 : (task.complexity ?? 3),
-                type: task.type || 'feature',
-                category: task.category || 'default',
-                approach: task.approach || null,
-                created_at: task.createdAt || new Date().toISOString(),
-                updated_at: task.updatedAt || null,
-                completed_at: task.completedAt || null,
-                canceled_reason: task.canceledReason || null,
-                scheduled_date: task.scheduledDate || null,
-                due_date: task.dueDate || null,
-                scheduled_week_key: task.scheduledWeekKey || null,
-                order_in_day: typeof task.orderInDay === 'number' ? Math.max(0, Math.round(task.orderInDay)) : null,
-                is_archived: isArchived,
-                specialists: JSON.stringify(task.specialists || []),
-                taxonomies: JSON.stringify(task.taxonomies || {}),
-                created_by: task.createdBy || null
-            });
-            if (task.comments && Array.isArray(task.comments)) {
-                for (const comment of task.comments) {
-                    insertComment.run({
-                        id: comment.id,
-                        tenant_id: tenantId,
-                        task_id: task.id,
-                        text: comment.text,
-                        author: comment.author,
-                        timestamp: comment.timestamp
-                    });
-                }
-            }
-            if (task.screenshots && Array.isArray(task.screenshots)) {
-                for (const s of task.screenshots) {
-                    if (typeof s === 'string') {
-                        insertScreenshot.run({
-                            id: `scr-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`,
-                            tenant_id: tenantId,
-                            task_id: task.id,
-                            path: s,
-                            fs_path: null,
-                            caption: null,
-                            timestamp: new Date().toISOString()
-                        });
-                    }
-                    else {
-                        insertScreenshot.run({
-                            id: `scr-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`,
-                            tenant_id: tenantId,
-                            task_id: task.id,
-                            path: s.path,
-                            fs_path: s.fsPath || null,
-                            caption: s.caption || null,
-                            timestamp: s.timestamp || new Date().toISOString()
-                        });
-                    }
-                }
-            }
-        }
-    });
-    transaction(tasksToMigrate);
-    console.log('[Taskforce] Migration complete.');
-}

package/dist/migrations/taskMigrations.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { normalizePriorityDefinitions } from './taskMigrations';
-describe('normalizePriorityDefinitions', () => {
-    it('repairs duplicate and missing values to canonical 1..4', () => {
-        const input = [
-            { value: 1, label: 'Low' },
-            { value: 2, label: 'Medium' },
-            { value: 3, label: 'High' },
-            { value: 3, label: 'Critical' }
-        ];
-        const result = normalizePriorityDefinitions(input);
-        expect(result.changed).toBe(true);
-        expect(result.priorities.map(p => p.value)).toEqual([1, 2, 3, 4]);
-        expect(result.priorities.find(p => p.value === 4)?.label).toBe('Critical');
-    });
-    it('returns canonical defaults when input is empty', () => {
-        const result = normalizePriorityDefinitions([]);
-        expect(result.changed).toBe(true);
-        expect(result.priorities.map(p => p.value)).toEqual([1, 2, 3, 4]);
-        expect(result.priorities.map(p => p.label)).toEqual(['Low', 'Medium', 'High', 'Critical']);
-    });
-    it('normalizes legacy 0..4 scale and clamps to current 1..4', () => {
-        const input = [
-            { value: 0, label: 'Legacy 0' },
-            { value: 1, label: 'Legacy 1' },
-            { value: 2, label: 'Legacy 2' },
-            { value: 3, label: 'Legacy 3' },
-            { value: 4, label: 'Legacy 4' }
-        ];
-        const result = normalizePriorityDefinitions(input);
-        expect(result.changed).toBe(true);
-        expect(result.priorities.map(p => p.value)).toEqual([1, 2, 3, 4]);
-    });
-});