@taskforcehq/taskforce 0.3.168

package/dist/mcp/structuredCommentValidation.d.ts

@@ -0,0 +1,6 @@
+export declare function validateStructuredCommentForAdd(text: string): {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/mcp/structuredCommentValidation.js

@@ -0,0 +1,56 @@
+const RULES = [
+    {
+        heading: '## Plan Summary',
+        requiredHeadings: [
+            '## Plan Summary',
+            '### Goal',
+            '### Scope',
+            '### Next Action'
+        ],
+        label: 'plan summary'
+    },
+    {
+        heading: '## Collaboration Summary',
+        requiredHeadings: [
+            '## Collaboration Summary',
+            '### Architecture Direction',
+            '### Key Constraints',
+            '### Next Step'
+        ],
+        label: 'collaboration summary'
+    },
+    {
+        heading: '## Evaluation Summary',
+        requiredHeadings: [
+            '## Evaluation Summary',
+            '### Recommendation (Proceed | Pivot | Kill)',
+            '### Value Score (1-5)',
+            '### Risk Score (1-5)',
+            '### Next Step'
+        ],
+        label: 'evaluation summary'
+    },
+    {
+        heading: '## Review Summary',
+        requiredHeadings: [
+            '## Review Summary',
+            '### Verdict (PASS | WARN | FAIL)',
+            '### Findings',
+            '### Next Status'
+        ],
+        label: 'review summary'
+    }
+];
+export function validateStructuredCommentForAdd(text) {
+    const trimmed = text.trim();
+    const activeRule = RULES.find((rule) => trimmed.startsWith(rule.heading));
+    if (!activeRule)
+        return { ok: true };
+    const missing = activeRule.requiredHeadings.filter((heading) => !trimmed.includes(heading));
+    if (missing.length === 0)
+        return { ok: true };
+    return {
+        ok: false,
+        message: `Structured ${activeRule.label} comment is missing required sections: ${missing.join(', ')}`
+    };
+}

package/dist/mcp/structuredDocValidation.d.ts

@@ -0,0 +1,6 @@
+export declare function validateStructuredDocForAttach(relativePath: string, content: string): {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/mcp/structuredDocValidation.js

@@ -0,0 +1,75 @@
+import path from 'path';
+const RULES = [
+    {
+        dirSegment: '/evaluations/',
+        filenameSuffixes: ['evaluation.md', '--evaluation.md'],
+        headings: [
+            '## Evaluation Summary',
+            '### Recommendation (Proceed | Pivot | Kill)',
+            '### Value Score (1-5)',
+            '### Risk Score (1-5)',
+            '### Alternatives Considered',
+            '### Key Tradeoffs',
+            '### Next Step'
+        ],
+        label: 'evaluation'
+    },
+    {
+        dirSegment: '/reviews/',
+        filenameSuffixes: ['review.md', '--review.md'],
+        headings: [
+            '## Review Verdict',
+            '### Verdict (PASS | WARN | FAIL)',
+            '### Findings',
+            '### Regression Risks',
+            '### Required Fixes',
+            '### Recommended Next Status'
+        ],
+        label: 'review'
+    },
+    {
+        dirSegment: '/collaborations/',
+        filenameSuffixes: ['collaboration-blueprint.md', '--collaboration-blueprint.md'],
+        headings: [
+            '## Collaboration Blueprint',
+            '### Problem Statement',
+            '### Constraints',
+            '### Proposed Architecture',
+            '### Must-Haves',
+            '### Non-Goals',
+            '### Risks & Open Questions',
+            '### Recommended Next Step'
+        ],
+        label: 'collaboration blueprint'
+    },
+    {
+        dirSegment: '/implementation_plans/',
+        filenameSuffixes: ['implementation-plan.md', '--implementation-plan.md'],
+        headings: [
+            '## Implementation Plan',
+            '### Goal',
+            '### Change Plan',
+            '### Risk Analysis',
+            '### Verification Checklist'
+        ],
+        label: 'implementation plan'
+    }
+];
+export function validateStructuredDocForAttach(relativePath, content) {
+    const normalizedPath = relativePath.split(path.sep).join('/');
+    const isLegacyDocPath = normalizedPath.startsWith('.taskforce/docs/');
+    const isTaskDataPath = normalizedPath.startsWith('.taskforce/task-data/');
+    if (!isLegacyDocPath && !isTaskDataPath)
+        return { ok: true };
+    const rule = RULES.find((r) => normalizedPath.includes(r.dirSegment) &&
+        r.filenameSuffixes.some((suffix) => normalizedPath.endsWith(suffix)));
+    if (!rule)
+        return { ok: true };
+    const missing = rule.headings.filter((heading) => !content.includes(heading));
+    if (missing.length === 0)
+        return { ok: true };
+    return {
+        ok: false,
+        message: `Structured ${rule.label} doc is missing required sections: ${missing.join(', ')}`
+    };
+}

package/dist/migrations/billingSchemaParity.test.d.ts

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

package/dist/migrations/billingSchemaParity.test.js

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { TaskforceCore } from '../core/Taskforce.js';
+function makeProjectRoot() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-billing-schema-'));
+}
+describe('billing schema parity', () => {
+    it('initializes sqlite billing tables and indexes', () => {
+        const projectRoot = makeProjectRoot();
+        const core = new TaskforceCore({
+            projectRoot,
+            storagePath: path.join(projectRoot, '.taskforce')
+        });
+        try {
+            const db = core.db;
+            const tables = db.prepare(`
+                SELECT name
+                FROM sqlite_master
+                WHERE type = 'table'
+            `).all();
+            const names = new Set(tables.map((row) => row.name));
+            expect(names.has('user_billing')).toBe(true);
+            expect(names.has('stripe_webhook_events')).toBe(true);
+            expect(names.has('stripe_webhook_failures')).toBe(true);
+            expect(names.has('billing_config')).toBe(true);
+            expect(names.has('billing_price_mappings')).toBe(true);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('postgres bootstrap contains billing tables and indexes', () => {
+        const sqlPath = path.resolve(process.cwd(), 'src/migrations/postgres/001_init.sql');
+        const sql = fs.readFileSync(sqlPath, 'utf8');
+        expect(sql).toContain('CREATE TABLE IF NOT EXISTS user_billing');
+        expect(sql).toContain('CREATE TABLE IF NOT EXISTS stripe_webhook_events');
+        expect(sql).toContain('CREATE TABLE IF NOT EXISTS stripe_webhook_failures');
+        expect(sql).toContain('CREATE TABLE IF NOT EXISTS billing_config');
+        expect(sql).toContain('CREATE TABLE IF NOT EXISTS billing_price_mappings');
+        expect(sql).toContain('CREATE INDEX IF NOT EXISTS idx_stripe_webhook_failures_purge_after');
+        expect(sql).toContain('CREATE INDEX IF NOT EXISTS idx_billing_price_mappings_plan');
+    });
+});

package/dist/migrations/clientMigrations.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,8 @@
+// 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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,236 @@
+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.d.ts

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

package/dist/migrations/taskMigrations.test.js

@@ -0,0 +1,34 @@
+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]);
+    });
+});

package/dist/migrations/taskSchemaMigrations.d.ts

@@ -0,0 +1,11 @@
+import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
+export declare function ensureTenantSchema(db: DatabaseAdapter): void;
+export declare function ensureParentTaskSchema(db: DatabaseAdapter): void;
+export declare function ensureScheduleTaskSchema(db: DatabaseAdapter): void;
+export declare function ensureAssigneeTaskSchema(db: DatabaseAdapter): void;
+export declare function ensureWorkspaceSchema(db: DatabaseAdapter): void;
+export declare function ensureBillingSchema(db: DatabaseAdapter): void;
+export declare function ensureEntitlementsSchema(db: DatabaseAdapter): void;
+export declare function ensureTaskAssetsSchema(db: DatabaseAdapter): void;
+export declare function ensureSyncEventsSchema(db: DatabaseAdapter): void;
+export declare function ensureWorkspaceDocumentsSchema(db: DatabaseAdapter): void;