@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/mcp/server.js

@@ -1,1793 +1,2 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListResourceTemplatesRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import * as fs from 'fs';
-import * as path from 'path';
-import { TaskforceCore } from '../core/Taskforce.js'; // Note .js extension for ESM
-import { COMPLEXITY_OPTIONS, resolveNumberOption, resolveStringOption, STATUS_OPTIONS } from './optionResolution.js';
-import { validateStructuredDocForAttach } from './structuredDocValidation.js';
-import { validateStructuredCommentForAdd } from './structuredCommentValidation.js';
-import { resolveDatabaseConfigFromEnv } from '../storage/providerConfig.js';
-// Initialize Core
-// We need to find project root.
-// In dev (tsx), we are in src/mcp/server.ts.
-// In prod (dist), we are in dist/mcp/server.js.
-// Project root is likely 2 levels up.
-const PROJECT_ROOT = process.argv[2]
-    ? path.resolve(process.argv[2])
-    : path.resolve(process.cwd());
-const PROJECT_NAME = path.basename(PROJECT_ROOT);
-console.error(`[Taskforce MCP] Starting for project: ${PROJECT_NAME} at ${PROJECT_ROOT}`);
-const db = resolveDatabaseConfigFromEnv();
-const tenantId = String(process.env.TASKFORCE_TENANT_ID || 'default').trim() || 'default';
-const MCP_SERVER_VERSION = (() => {
-    try {
-        const packagePath = path.resolve(PROJECT_ROOT, 'package.json');
-        const raw = fs.readFileSync(packagePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        const version = String(parsed?.version || '').trim();
-        return version || '0.0.0-dev';
-    }
-    catch {
-        return '0.0.0-dev';
-    }
-})();
-const core = new TaskforceCore({
-    projectRoot: PROJECT_ROOT,
-    tenantId,
-    database: {
-        provider: db.provider,
-        connectionString: db.connectionString
-    }
-});
-const workspaceFromEnv = String(process.env.TASKFORCE_WORKSPACE_ID || '').trim();
-let ACTIVE_WORKSPACE_ID = '';
-const workspaceFromEnvValid = workspaceFromEnv && workspaceFromEnv.toLowerCase() !== 'default'
-    ? workspaceFromEnv
-    : '';
-if (workspaceFromEnv && !workspaceFromEnvValid) {
-    console.warn('[Taskforce MCP] Ignoring TASKFORCE_WORKSPACE_ID=default. Resolving non-default workspace automatically.');
-}
-if (workspaceFromEnvValid) {
-    if (!core.workspaceExists(workspaceFromEnv)) {
-        throw new Error(`[Taskforce MCP] Configured workspace not found for tenant ${tenantId}: ${workspaceFromEnv}`);
-    }
-    ACTIVE_WORKSPACE_ID = workspaceFromEnvValid;
-}
-else {
-    const inferredWorkspaceId = core.resolvePreferredWorkspaceId({ allowDefault: false });
-    if (!inferredWorkspaceId) {
-        throw new Error('[Taskforce MCP] Unable to resolve workspace scope. Set TASKFORCE_WORKSPACE_ID explicitly.');
-    }
-    ACTIVE_WORKSPACE_ID = inferredWorkspaceId;
-}
-console.error(`[Taskforce MCP] Scope resolved: tenant=${tenantId} workspace=${ACTIVE_WORKSPACE_ID}`);
-const server = new Server({
-    name: `taskforce-${PROJECT_NAME}`,
-    version: MCP_SERVER_VERSION,
-}, {
-    capabilities: {
-        resources: {
-            subscribe: true,
-            listChanged: true,
-        },
-        tools: {},
-    },
-});
-/**
- * Helpers
- */
-function renderTaskTable(tasks) {
-    if (tasks.length === 0)
-        return "No tasks found.";
-    let table = "| ID | Title | Status | Assignee | Category | Priority |\n";
-    table += "|---|---|---|---|---|---|\n";
-    for (const task of tasks) {
-        table += `| \`${task.id}\` | ${task.title} | \`${task.status}\` | \`${task.assignee || 'unassigned'}\` | ${task.category} | ${task.priority} |\n`;
-    }
-    return table;
-}
-function isHttpUrl(value) {
-    return /^https?:\/\//i.test(value);
-}
-function isWithinRoot(filePath, root) {
-    const relative = path.relative(root, filePath);
-    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
-}
-function toPosixPath(filePath) {
-    return filePath.split(path.sep).join('/');
-}
-function sanitizeTaskIdForPath(taskIdRaw) {
-    const value = typeof taskIdRaw === 'string' ? taskIdRaw.trim() : '';
-    if (!value)
-        return '_unassigned';
-    return value.replace(/[^a-zA-Z0-9._-]/g, '-');
-}
-function sanitizeFilenameForPath(filenameRaw, fallback = 'attachment.txt') {
-    const value = typeof filenameRaw === 'string' ? filenameRaw.trim() : '';
-    const basename = path.basename(value || fallback);
-    const sanitized = basename
-        .replace(/[^a-zA-Z0-9._-]/g, '-')
-        .replace(/^\.+/, '');
-    return sanitized || fallback;
-}
-function nextAvailablePath(targetPath) {
-    if (!fs.existsSync(targetPath))
-        return targetPath;
-    const parsed = path.parse(targetPath);
-    let counter = 2;
-    while (true) {
-        const nextPath = path.join(parsed.dir, `${parsed.name}-${counter}${parsed.ext}`);
-        if (!fs.existsSync(nextPath))
-            return nextPath;
-        counter += 1;
-    }
-}
-function buildRelationshipAuditComment(taskId, previousParentId, nextParentId) {
-    if (previousParentId === nextParentId)
-        return null;
-    if (!previousParentId && !nextParentId)
-        return null;
-    const timestamp = new Date().toISOString();
-    if (!previousParentId && nextParentId) {
-        return [
-            '## AI Relationship Audit',
-            '### Action',
-            'link-child',
-            '### Task',
-            taskId,
-            '### From Parent',
-            'none',
-            '### To Parent',
-            nextParentId,
-            '### Timestamp',
-            timestamp
-        ].join('\n');
-    }
-    if (previousParentId && !nextParentId) {
-        return [
-            '## AI Relationship Audit',
-            '### Action',
-            'unlink-child',
-            '### Task',
-            taskId,
-            '### From Parent',
-            previousParentId,
-            '### To Parent',
-            'none',
-            '### Timestamp',
-            timestamp
-        ].join('\n');
-    }
-    return [
-        '## AI Relationship Audit',
-        '### Action',
-        're-parent-child',
-        '### Task',
-        taskId,
-        '### From Parent',
-        previousParentId,
-        '### To Parent',
-        nextParentId,
-        '### Timestamp',
-        timestamp
-    ].join('\n');
-}
-function buildBatchSummary(params) {
-    const failed = Math.max(0, params.total - params.succeeded);
-    return {
-        operation: params.operation,
-        total: params.total,
-        succeeded: params.succeeded,
-        failed,
-        partial: params.succeeded > 0 && failed > 0
-    };
-}
-function parseDateOnlyLocal(dateOnly) {
-    const match = String(dateOnly || '').trim().match(/^(\d{4})-(\d{2})-(\d{2})$/);
-    if (!match)
-        return null;
-    const date = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
-    if (Number.isNaN(date.getTime()))
-        return null;
-    return date;
-}
-function formatDateOnlyLocal(date) {
-    const y = date.getFullYear();
-    const m = String(date.getMonth() + 1).padStart(2, '0');
-    const d = String(date.getDate()).padStart(2, '0');
-    return `${y}-${m}-${d}`;
-}
-function addDaysDateOnly(dateOnly, days) {
-    const parsed = parseDateOnlyLocal(dateOnly);
-    if (!parsed)
-        return null;
-    const next = new Date(parsed);
-    next.setDate(parsed.getDate() + days);
-    return formatDateOnlyLocal(next);
-}
-function normalizeScheduleFieldAliases(input) {
-    const next = { ...input };
-    if (next.scheduledDate === undefined && next.scheduleDate !== undefined) {
-        next.scheduledDate = next.scheduleDate;
-    }
-    if (next.scheduledWeekKey === undefined && next.scheduleWeekKey !== undefined) {
-        next.scheduledWeekKey = next.scheduleWeekKey;
-    }
-    delete next.scheduleDate;
-    delete next.scheduleWeekKey;
-    return next;
-}
-const RESOURCE_URI_PREFIX = `taskforce://${PROJECT_NAME}`;
-const RESOURCE_CONFIG_URI = `${RESOURCE_URI_PREFIX}/config`;
-const RESOURCE_STATS_URI = `${RESOURCE_URI_PREFIX}/stats`;
-const RESOURCE_TASKS_URI = `${RESOURCE_URI_PREFIX}/tasks`;
-const RESOURCE_TASK_TEMPLATE_URI = `${RESOURCE_URI_PREFIX}/tasks/{id}`;
-const resourceSubscriptions = new Set();
-const ASSIGNEE_OPTIONS = [
-    { value: 'unassigned', label: 'Unassigned' },
-    { value: 'agent', label: 'Agent' },
-    { value: 'user', label: 'User' }
-];
-function taskUriFor(id) {
-    return `${RESOURCE_URI_PREFIX}/tasks/${encodeURIComponent(id)}`;
-}
-function parseTaskIdFromUri(uri) {
-    if (!uri.startsWith(`${RESOURCE_URI_PREFIX}/tasks/`))
-        return null;
-    const encodedId = uri.slice(`${RESOURCE_URI_PREFIX}/tasks/`.length).trim();
-    if (!encodedId)
-        return null;
-    return decodeURIComponent(encodedId);
-}
-function isSupportedResourceUri(uri) {
-    return uri === RESOURCE_CONFIG_URI
-        || uri === RESOURCE_STATS_URI
-        || uri === RESOURCE_TASKS_URI
-        || parseTaskIdFromUri(uri) !== null;
-}
-async function notifyResourceUpdatedIfSubscribed(uri) {
-    if (!resourceSubscriptions.has(uri))
-        return;
-    try {
-        await server.sendResourceUpdated({ uri });
-    }
-    catch (error) {
-        console.error(`[Taskforce MCP] Failed to send resources/updated for ${uri}: ${error.message}`);
-    }
-}
-async function notifyResourceMutation(options) {
-    const uris = new Set();
-    if (options.includeConfig)
-        uris.add(RESOURCE_CONFIG_URI);
-    if (options.includeStats)
-        uris.add(RESOURCE_STATS_URI);
-    if (options.includeTasks)
-        uris.add(RESOURCE_TASKS_URI);
-    for (const taskId of options.taskIds ?? []) {
-        if (taskId && typeof taskId === 'string') {
-            uris.add(taskUriFor(taskId));
-        }
-    }
-    for (const uri of uris) {
-        await notifyResourceUpdatedIfSubscribed(uri);
-    }
-}
-function buildConfigResourcePayload() {
-    return {
-        project: {
-            name: PROJECT_NAME,
-            root: PROJECT_ROOT,
-        },
-        categories: core.getCategories(),
-        types: core.getTypes(),
-        priorities: core.getPriorities(),
-        approaches: core.getApproaches(),
-    };
-}
-function buildTasksResourcePayload() {
-    const tasks = core.listTasks(ACTIVE_WORKSPACE_ID).tasks;
-    return {
-        total: tasks.length,
-        tasks,
-    };
-}
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return {
-        resources: [
-            {
-                uri: RESOURCE_CONFIG_URI,
-                name: `${PROJECT_NAME} Config`,
-                title: `${PROJECT_NAME} Project Configuration`,
-                description: "Resolved Taskforce categories, types, priorities, and approaches.",
-                mimeType: "application/json",
-            },
-            {
-                uri: RESOURCE_STATS_URI,
-                name: `${PROJECT_NAME} Stats`,
-                title: `${PROJECT_NAME} Task Statistics`,
-                description: "Current active and archived task counts by status and priority.",
-                mimeType: "application/json",
-            },
-            {
-                uri: RESOURCE_TASKS_URI,
-                name: `${PROJECT_NAME} Tasks`,
-                title: `${PROJECT_NAME} Active Task List`,
-                description: "All active tasks as JSON.",
-                mimeType: "application/json",
-            },
-        ],
-    };
-});
-server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
-    return {
-        resourceTemplates: [
-            {
-                uriTemplate: RESOURCE_TASK_TEMPLATE_URI,
-                name: `${PROJECT_NAME} Task`,
-                title: `${PROJECT_NAME} Task By ID`,
-                description: "Read one task by ID. Example URI: " + taskUriFor("task-123"),
-                mimeType: "application/json",
-            },
-        ],
-    };
-});
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const uri = request.params.uri;
-    if (uri === RESOURCE_CONFIG_URI) {
-        return {
-            contents: [
-                {
-                    uri,
-                    mimeType: "application/json",
-                    text: JSON.stringify(buildConfigResourcePayload(), null, 2),
-                },
-            ],
-        };
-    }
-    if (uri === RESOURCE_STATS_URI) {
-        return {
-            contents: [
-                {
-                    uri,
-                    mimeType: "application/json",
-                    text: JSON.stringify(core.getStats(ACTIVE_WORKSPACE_ID), null, 2),
-                },
-            ],
-        };
-    }
-    if (uri === RESOURCE_TASKS_URI) {
-        return {
-            contents: [
-                {
-                    uri,
-                    mimeType: "application/json",
-                    text: JSON.stringify(buildTasksResourcePayload(), null, 2),
-                },
-            ],
-        };
-    }
-    const taskId = parseTaskIdFromUri(uri);
-    if (taskId) {
-        const task = core.getTask(taskId, ACTIVE_WORKSPACE_ID);
-        if (!task) {
-            throw new Error(`Task not found for URI: ${uri}`);
-        }
-        return {
-            contents: [
-                {
-                    uri,
-                    mimeType: "application/json",
-                    text: JSON.stringify(task, null, 2),
-                },
-            ],
-        };
-    }
-    throw new Error(`Unknown resource URI: ${uri}`);
-});
-server.setRequestHandler(SubscribeRequestSchema, async (request) => {
-    const uri = request.params.uri;
-    if (!isSupportedResourceUri(uri)) {
-        throw new Error(`Unsupported resource URI for subscribe: ${uri}`);
-    }
-    resourceSubscriptions.add(uri);
-    return {};
-});
-server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
-    const uri = request.params.uri;
-    if (!isSupportedResourceUri(uri)) {
-        throw new Error(`Unsupported resource URI for unsubscribe: ${uri}`);
-    }
-    resourceSubscriptions.delete(uri);
-    return {};
-});
-/**
- * Tool Definitions
- */
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const priorities = core.getPriorities();
-    const approaches = core.getApproaches();
-    const types = core.getTypes();
-    const priorityDesc = "Priority level: " + priorities.map(p => `${p.value} (${p.label})`).join(', ');
-    const approachEnum = approaches.map(a => a.value);
-    const typeEnum = types.map(t => t.value);
-    const complexityDesc = "Complexity level: 1 (Tiny), 2 (Low), 3 (Medium), 4 (High), 5 (Epic)";
-    const optionPreflight = "Before setting category/type/priority/approach/status/complexity, call get_config to read current valid values. ";
-    const prefix = `[Project: ${PROJECT_NAME}] `;
-    const agentNote = " NOTE: Use this tool instead of editing files directly to ensure data integrity.";
-    return {
-        tools: [
-            {
-                name: "list_tasks",
-                description: prefix + "List all active task items." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        format: { type: "string", enum: ["markdown", "json"], description: "Toggle output format (default: markdown)" },
-                        category: { type: "string", description: "Filter by category" },
-                        status: { type: "string", enum: ["task", "on-hold", "in-progress", "review", "done", "cancelled"], description: "Filter by status" },
-                        parentTaskId: { type: "string", description: "Filter by parent task ID (direct children only)." },
-                        openOnly: { type: "boolean", description: "When true, only include open tasks (task, on-hold, in-progress, review)." },
-                        assignee: { type: "string", enum: ["unassigned", "agent", "user"], description: "Filter by assignee" },
-                        priority: { type: "number", description: "Filter by priority level" },
-                        type: { type: "string", enum: typeEnum, description: "Filter by task type" },
-                        sort: { type: "string", enum: ["priority", "created", "updated"], description: "Sort field (default: created)" },
-                        order: { type: "string", enum: ["asc", "desc"], description: "Sort order (default: desc)" },
-                        limit: { type: "number", description: "Max tasks to return" }
-                    },
-                },
-            },
-            {
-                name: "search_tasks",
-                description: prefix + "Search for tasks (active and archived) by query string." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: { type: "string", description: "Search term (matches title, description, or ID)" },
-                        scope: { type: "string", enum: ["all", "active", "archive"], description: "Search scope (default: all)" }
-                    },
-                    required: ["query"]
-                }
-            },
-            {
-                name: "get_task",
-                description: prefix + "Get a specific task item by ID (checks active and archive)" + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string" }
-                    },
-                    required: ["id"],
-                },
-            },
-            {
-                name: "get_schedule_board",
-                description: prefix + "Get schedule board state for a target week (backlog/expired/day columns)." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        week: { type: "string", description: "ISO week key (e.g., 2026-W08)" },
-                        showWeekends: { type: "boolean", description: "Include Saturday/Sunday columns (default: false)" }
-                    },
-                    required: ["week"],
-                },
-            },
-            {
-                name: "schedule_task",
-                description: prefix + "Schedule a task to a date/order. Leaf-only validation and scheduling warnings are enforced." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string" },
-                        scheduledDate: { type: "string", description: "Date-only value (YYYY-MM-DD)" },
-                        orderInDay: { type: "number", description: "Optional order index within the scheduled day" }
-                    },
-                    required: ["id", "scheduledDate"],
-                },
-            },
-            {
-                name: "unschedule_task",
-                description: prefix + "Move a task back to backlog by clearing schedule fields." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string" }
-                    },
-                    required: ["id"],
-                },
-            },
-            {
-                name: "reorder_scheduled_tasks",
-                description: prefix + "Apply multiple schedule/date/order moves in one operation." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        moves: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    id: { type: "string" },
-                                    scheduledDate: { type: ["string", "null"] },
-                                    orderInDay: { type: "number" }
-                                },
-                                required: ["id", "scheduledDate"]
-                            }
-                        }
-                    },
-                    required: ["moves"],
-                },
-            },
-            {
-                name: "bulk_carryover",
-                description: prefix + "Carry over unfinished scheduled tasks by day or week." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        fromWeek: { type: "string", description: "Source ISO week key (e.g., 2026-W08)" },
-                        toWeek: { type: "string", description: "Target ISO week key (currently informational; date shift is mode-based)" },
-                        mode: { type: "string", enum: ["day", "week"], description: "Shift scheduled dates by 1 day or 7 days" },
-                        includeStatuses: {
-                            type: "array",
-                            items: { type: "string", enum: ["task", "on-hold", "in-progress", "review", "done", "cancelled"] },
-                            description: "Statuses eligible for carryover (default: task,in-progress,review,on-hold)"
-                        }
-                    },
-                    required: ["fromWeek", "toWeek", "mode"],
-                },
-            },
-            {
-                name: "set_schedule_preferences",
-                description: prefix + "Persist schedule preferences used by planning flows." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        showWeekends: { type: "boolean" },
-                        isCalendarSidebarOpen: { type: "boolean" },
-                        dailyCapacity: {
-                            type: "object",
-                            properties: {
-                                monday: { type: "number" },
-                                tuesday: { type: "number" },
-                                wednesday: { type: "number" },
-                                thursday: { type: "number" },
-                                friday: { type: "number" },
-                                saturday: { type: "number" },
-                                sunday: { type: "number" }
-                            }
-                        }
-                    },
-                },
-            },
-            {
-                name: "create_task",
-                description: prefix + "Create a new task item. " + optionPreflight + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        title: { type: "string" },
-                        description: { type: "string" },
-                        category: { type: "string" },
-                        type: { type: "string", enum: typeEnum },
-                        priority: { type: "number", description: priorityDesc },
-                        complexity: { type: "number", description: complexityDesc },
-                        status: { type: "string", enum: ["task", "on-hold", "in-progress", "review"], description: "Initial status (default: task)" },
-                        approach: { type: "string", enum: approachEnum },
-                        assignee: { type: "string", enum: ["unassigned", "agent", "user"], description: "Task owner assignment" },
-                        owner: { type: "string", enum: ["unassigned", "agent", "user"], description: "Alias for assignee (task owner assignment)" },
-                        scheduledDate: { type: "string", description: "Optional schedule date in YYYY-MM-DD format" },
-                        dueDate: { type: "string", description: "Optional due date in YYYY-MM-DD format" },
-                        orderInDay: { type: "number", description: "Optional sort order within scheduledDate" },
-                        parentTaskId: { type: "string", description: "Optional parent task ID. Empty/omitted means top-level task." },
-                        childDisplayOrder: { type: "number", description: "Optional display-only child order index (lower comes first among siblings)." },
-                        specialists: { type: "array", items: { type: "string" }, description: "List of specialist skill IDs to assign" }
-                    },
-                    required: ["title"],
-                },
-            },
-            {
-                name: "update_task",
-                description: prefix + "Update an existing task item. " + optionPreflight + "Status reflects workflow state (task/on-hold/in-progress/review/done/cancelled). Archiving moves tasks to history - use archive_task for that." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string" },
-                        title: { type: "string" },
-                        description: { type: "string" },
-                        category: { type: "string" },
-                        type: { type: "string", enum: typeEnum },
-                        priority: { type: "number", description: priorityDesc },
-                        complexity: { type: "number", description: complexityDesc },
-                        approach: { type: "string", enum: approachEnum },
-                        assignee: { type: "string", enum: ["unassigned", "agent", "user"], description: "Task owner assignment" },
-                        owner: { type: "string", enum: ["unassigned", "agent", "user"], description: "Alias for assignee (task owner assignment)" },
-                        scheduledDate: { type: "string", description: "Set schedule date (YYYY-MM-DD)" },
-                        dueDate: { type: "string", description: "Set due date (YYYY-MM-DD)" },
-                        orderInDay: { type: "number", description: "Set order index within scheduledDate" },
-                        status: { type: "string", enum: ["task", "on-hold", "in-progress", "review", "done", "cancelled"] },
-                        parentTaskId: { type: "string", description: "Set to a parent task ID, or empty string to unlink." },
-                        childDisplayOrder: { type: "number", description: "Optional display-only child order index (lower comes first among siblings)." },
-                        specialists: { type: "array", items: { type: "string" }, description: "Update list of assigned specialists" },
-                        canceledReason: { type: "string", description: "Reason for cancellation" }
-                    },
-                    required: ["id"],
-                },
-            },
-            {
-                name: "assign_task",
-                description: prefix + "Assign a task owner explicitly (user/agent/unassigned)." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string" },
-                        assignee: { type: "string", enum: ["unassigned", "agent", "user"] }
-                    },
-                    required: ["id", "assignee"],
-                },
-            },
-            {
-                name: "bulk_assign_tasks",
-                description: prefix + "Assign many tasks to one owner explicitly (user/agent/unassigned)." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        ids: { type: "array", items: { type: "string" } },
-                        assignee: { type: "string", enum: ["unassigned", "agent", "user"] }
-                    },
-                    required: ["ids", "assignee"],
-                },
-            },
-            {
-                name: "archive_task",
-                description: prefix + "Archive a task item (moving to history). This is the preferred way to 'remove' completed or cancelled tasks." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string" },
-                        status: { type: "string", enum: ["done", "cancelled"], description: "Final status when archiving" },
-                        reason: { type: "string", description: "Reason for cancellation" }
-                    },
-                    required: ["id", "status"],
-                },
-            },
-            {
-                name: "add_comment",
-                description: prefix + "Add a comment to a task item." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string" },
-                        text: { type: "string" },
-                        author: { type: "string", description: "Comment author identity. Use 'user' for human comments, or AI identifiers such as 'ai', 'codex', 'antigravity', 'claude', etc." }
-                    },
-                    required: ["id", "text", "author"],
-                },
-            },
-            {
-                name: "attach_context_file",
-                description: prefix + "Attach a project file or URL to a task as context. Local files must be inside the project root." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string", description: "Task ID" },
-                        path: { type: "string", description: "File path (absolute or project-relative) or an http(s) URL" },
-                        caption: { type: "string", description: "Optional label shown in task context" }
-                    },
-                    required: ["id", "path"],
-                },
-            },
-            {
-                name: "save_task_attachment",
-                description: prefix + "Save task-specific content or a copied file into .taskforce/task-data/{taskId}/attachments and attach it to the task." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string", description: "Task ID" },
-                        filename: { type: "string", description: "Target filename in the task attachments folder." },
-                        content: { type: "string", description: "Text/markdown file content to save. Provide either content or sourcePath." },
-                        sourcePath: { type: "string", description: "Project-relative or absolute source file path to copy. Provide either sourcePath or content." },
-                        caption: { type: "string", description: "Optional label shown in task context" },
-                        overwrite: { type: "boolean", description: "Overwrite the destination file when it already exists (default: false)." }
-                    },
-                    required: ["id", "filename"],
-                },
-            },
-            {
-                name: "list_archive",
-                description: prefix + "List all archived task items." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        format: { type: "string", enum: ["markdown", "json"], description: "Toggle output format (default: markdown)" }
-                    },
-                },
-            },
-            {
-                name: "unarchive_task",
-                description: prefix + "Move a task from archive back to active." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        id: { type: "string" }
-                    },
-                    required: ["id"],
-                },
-            },
-            {
-                name: "bulk_archive",
-                description: prefix + "Archive multiple task items at once." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        ids: { type: "array", items: { type: "string" } },
-                        status: { type: "string", enum: ["done", "cancelled"], description: "Status for all archived items (default: done)" }
-                    },
-                    required: ["ids"],
-                },
-            },
-            {
-                name: "get_config",
-                description: prefix + "Get full Taskforce configuration (types, priorities, approaches, categories)." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                },
-            },
-            {
-                name: "update_categories",
-                description: prefix + "Update category definitions." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        categories: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    value: { type: "string" },
-                                    label: { type: "string" },
-                                    icon: { type: "string" },
-                                    color: { type: "string" }
-                                },
-                                required: ["value", "label"]
-                            }
-                        }
-                    },
-                    required: ["categories"],
-                },
-            },
-            {
-                name: "update_types",
-                description: prefix + "Update task type definitions." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        types: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    value: { type: "string" },
-                                    label: { type: "string" }
-                                },
-                                required: ["value", "label"]
-                            }
-                        }
-                    },
-                    required: ["types"],
-                },
-            },
-            {
-                name: "bulk_update_type",
-                description: prefix + "Change the type of multiple tasks." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        fromType: { type: "string" },
-                        toType: { type: "string" }
-                    },
-                    required: ["fromType", "toType"],
-                },
-            },
-            {
-                name: "bulk_update_fields",
-                description: prefix + "Update specific fields for multiple tasks at once. Efficient for batch operations like reprioritizing or recategorizing. " + optionPreflight + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        updates: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    id: { type: "string" },
-                                    title: { type: "string" },
-                                    description: { type: "string" },
-                                    category: { type: "string" },
-                                    type: { type: "string", enum: typeEnum },
-                                    priority: { type: "number", description: priorityDesc },
-                                    complexity: { type: "number", description: complexityDesc },
-                                    approach: { type: "string", enum: approachEnum },
-                                    assignee: { type: "string", enum: ["unassigned", "agent", "user"] },
-                                    owner: { type: "string", enum: ["unassigned", "agent", "user"], description: "Alias for assignee" },
-                                    status: { type: "string", enum: ["task", "on-hold", "in-progress", "review", "done", "cancelled"] },
-                                    specialists: { type: "array", items: { type: "string" } }
-                                },
-                                required: ["id"]
-                            }
-                        }
-                    },
-                    required: ["updates"],
-                },
-            },
-            {
-                name: "list_skills",
-                description: prefix + "List available skills (also known as agents or specialists)." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                },
-            },
-            {
-                name: "export_resources",
-                description: prefix + "Export templates (workflows/skills) to the project." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        type: { type: "string", enum: ["workflows", "skills"] },
-                        path: { type: "string" },
-                        variables: { type: "object", additionalProperties: { type: "string" } },
-                        environment: { type: "string", enum: ["aider", "antigravity", "claude", "cline", "codex", "copilot", "cursor", "gemini", "windsurf"], description: "Target environment/IDE" }
-                    },
-                    required: ["type", "path"],
-                },
-            },
-            {
-                name: "get_paths",
-                description: prefix + "Get project and storage paths." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                },
-            },
-            {
-                name: "update_priorities",
-                description: prefix + "Update priority level definitions." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        priorities: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    value: { type: "number" },
-                                    label: { type: "string" },
-                                    color: { type: "string" },
-                                    icon: { type: "string" }
-                                },
-                                required: ["value", "label"]
-                            }
-                        }
-                    },
-                    required: ["priorities"],
-                },
-            },
-            {
-                name: "update_approaches",
-                description: prefix + "Update approach definitions." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        approaches: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    value: { type: "string" },
-                                    label: { type: "string" },
-                                    color: { type: "string" },
-                                    icon: { type: "string" }
-                                },
-                                required: ["value", "label"]
-                            }
-                        }
-                    },
-                    required: ["approaches"],
-                },
-            },
-            {
-                name: "get_stats",
-                description: prefix + "Get task statistics for situational awareness (counts by status, priority, etc)." + agentNote,
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                },
-            }
-        ],
-    };
-});
-/**
- * Tool Execution
- */
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        switch (name) {
-            case "list_tasks": {
-                const { format = "markdown", category, status, parentTaskId, openOnly = false, assignee, priority, type, sort = "created", order = "desc", limit } = args;
-                let data = core.listTasks(ACTIVE_WORKSPACE_ID);
-                let tasks = data.tasks;
-                const openStatuses = new Set(["task", "on-hold", "in-progress", "review"]);
-                // Filtering
-                if (category)
-                    tasks = tasks.filter(t => t.category === category);
-                if (status)
-                    tasks = tasks.filter(t => t.status === status);
-                if (parentTaskId !== undefined) {
-                    const normalizedParentTaskId = String(parentTaskId || "").trim();
-                    tasks = tasks.filter(t => (t.parentTaskId || "") === normalizedParentTaskId);
-                }
-                if (openOnly)
-                    tasks = tasks.filter(t => openStatuses.has(t.status));
-                if (assignee)
-                    tasks = tasks.filter(t => (t.assignee || 'unassigned') === assignee);
-                if (priority !== undefined)
-                    tasks = tasks.filter(t => t.priority === Number(priority));
-                if (type)
-                    tasks = tasks.filter(t => t.type === type);
-                // Sorting
-                tasks.sort((a, b) => {
-                    let aVal, bVal;
-                    if (sort === "priority") {
-                        aVal = a.priority;
-                        bVal = b.priority;
-                    }
-                    else if (sort === "updated") {
-                        aVal = a.updatedAt || a.createdAt;
-                        bVal = b.updatedAt || b.createdAt;
-                    }
-                    else {
-                        aVal = a.createdAt;
-                        bVal = b.createdAt;
-                    }
-                    const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-                    return order === "asc" ? cmp : -cmp;
-                });
-                // Limiting
-                if (limit && limit > 0) {
-                    tasks = tasks.slice(0, limit);
-                }
-                if (format === "json") {
-                    return {
-                        content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }],
-                    };
-                }
-                return {
-                    content: [{ type: "text", text: renderTaskTable(tasks) }],
-                };
-            }
-            case "search_tasks": {
-                const { query, scope = "all" } = args;
-                const results = core.searchTasks(query, scope, ACTIVE_WORKSPACE_ID);
-                return {
-                    content: [{ type: "text", text: renderTaskTable(results) }],
-                };
-            }
-            case "get_task": {
-                const { id } = args;
-                const task = core.getTask(id, ACTIVE_WORKSPACE_ID);
-                if (!task) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                return {
-                    content: [{ type: "text", text: JSON.stringify(task, null, 2) }],
-                };
-            }
-            case "get_schedule_board": {
-                const { week, showWeekends = false } = args;
-                if (!week || typeof week !== 'string') {
-                    throw new Error('week is required');
-                }
-                const board = core.getScheduleBoard(week, Boolean(showWeekends), ACTIVE_WORKSPACE_ID);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(board, null, 2) }],
-                };
-            }
-            case "schedule_task": {
-                const { id, scheduledDate, orderInDay } = args;
-                if (!id || typeof id !== 'string')
-                    throw new Error('id is required');
-                if (!scheduledDate || typeof scheduledDate !== 'string')
-                    throw new Error('scheduledDate is required');
-                const result = core.updateTaskSchedule(id, { scheduledDate, orderInDay }, ACTIVE_WORKSPACE_ID);
-                if (!result) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                scheduling: {
-                                    taskId: id,
-                                    requestedDate: scheduledDate,
-                                    persistedDate: result.task.scheduledDate,
-                                    persistedWeekKey: result.task.scheduledWeekKey,
-                                    persistedOrderInDay: result.task.orderInDay ?? null
-                                },
-                                warnings: result.warnings,
-                                task: result.task
-                            }, null, 2)
-                        }],
-                };
-            }
-            case "unschedule_task": {
-                const { id } = args;
-                if (!id || typeof id !== 'string')
-                    throw new Error('id is required');
-                const result = core.updateTaskSchedule(id, { scheduledDate: null, orderInDay: null }, ACTIVE_WORKSPACE_ID);
-                if (!result) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                scheduling: {
-                                    taskId: id,
-                                    requestedDate: null,
-                                    persistedDate: result.task.scheduledDate,
-                                    persistedWeekKey: result.task.scheduledWeekKey,
-                                    persistedOrderInDay: result.task.orderInDay ?? null
-                                },
-                                warnings: result.warnings,
-                                task: result.task
-                            }, null, 2)
-                        }],
-                };
-            }
-            case "reorder_scheduled_tasks": {
-                const { moves } = args;
-                if (!Array.isArray(moves)) {
-                    throw new Error('moves must be an array');
-                }
-                const result = core.reorderScheduledTasks(moves, ACTIVE_WORKSPACE_ID);
-                await notifyResourceMutation({
-                    taskIds: moves.map((m) => m?.id).filter((id) => typeof id === 'string'),
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case "bulk_carryover": {
-                const { fromWeek, toWeek, mode, includeStatuses = ['task', 'in-progress', 'review', 'on-hold'] } = args;
-                if (!fromWeek || typeof fromWeek !== 'string')
-                    throw new Error('fromWeek is required');
-                if (!toWeek || typeof toWeek !== 'string')
-                    throw new Error('toWeek is required');
-                if (mode !== 'day' && mode !== 'week')
-                    throw new Error('mode must be "day" or "week"');
-                const shiftDays = mode === 'day' ? 1 : 7;
-                const activeStatuses = Array.isArray(includeStatuses) ? includeStatuses.map((s) => String(s)) : [];
-                const tasks = core.listTasks(ACTIVE_WORKSPACE_ID).tasks.filter((task) => {
-                    if (!task.scheduledDate)
-                        return false;
-                    if (task.scheduledWeekKey !== fromWeek)
-                        return false;
-                    if (task.status === 'done' || task.status === 'cancelled')
-                        return false;
-                    return activeStatuses.length === 0 || activeStatuses.includes(task.status);
-                });
-                const updates = [];
-                for (const task of tasks) {
-                    const nextDate = addDaysDateOnly(String(task.scheduledDate), shiftDays);
-                    if (!nextDate)
-                        continue;
-                    core.updateTaskSchedule(task.id, { scheduledDate: nextDate, orderInDay: task.orderInDay ?? undefined }, ACTIVE_WORKSPACE_ID);
-                    updates.push({ id: task.id, from: String(task.scheduledDate), to: nextDate });
-                }
-                await notifyResourceMutation({
-                    taskIds: updates.map(u => u.id),
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                fromWeek,
-                                toWeek,
-                                mode,
-                                shiftedDays: shiftDays,
-                                moved: updates.length,
-                                updates
-                            }, null, 2)
-                        }],
-                };
-            }
-            case "set_schedule_preferences": {
-                const { showWeekends, isCalendarSidebarOpen, dailyCapacity } = args;
-                const schedulePreferences = {
-                    ...(typeof showWeekends === 'boolean' ? { showWeekends } : {}),
-                    ...(typeof isCalendarSidebarOpen === 'boolean' ? { isCalendarSidebarOpen } : {}),
-                    ...(dailyCapacity && typeof dailyCapacity === 'object' ? { dailyCapacity } : {})
-                };
-                core.updateGlobalSettings({ schedulePreferences });
-                const updated = core.getGlobalSettings();
-                await notifyResourceMutation({
-                    includeConfig: true,
-                });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                schedulePreferences: updated.schedulePreferences || {}
-                            }, null, 2)
-                        }],
-                };
-            }
-            case "create_task": {
-                const createArgs = normalizeScheduleFieldAliases(args);
-                const createAssigneeInput = createArgs.assignee ?? createArgs.owner;
-                const normalized = {
-                    category: resolveStringOption('category', createArgs.category, core.getCategories().map(c => ({ value: c.value, label: c.label }))),
-                    type: resolveStringOption('type', createArgs.type, core.getTypes().map(t => ({ value: t.value, label: t.label }))),
-                    priority: resolveNumberOption('priority', createArgs.priority, core.getPriorities().map(p => ({ value: p.value, label: p.label }))),
-                    approach: resolveStringOption('approach', createArgs.approach, core.getApproaches().map(a => ({ value: a.value, label: a.label }))),
-                    assignee: resolveStringOption('assignee', createAssigneeInput, [...ASSIGNEE_OPTIONS]),
-                    status: resolveStringOption('status', createArgs.status, STATUS_OPTIONS),
-                    complexity: resolveNumberOption('complexity', createArgs.complexity, COMPLEXITY_OPTIONS)
-                };
-                const task = core.createTask({
-                    ...createArgs,
-                    ...normalized,
-                    createdBy: 'AI Agent'
-                }, { workspaceId: ACTIVE_WORKSPACE_ID });
-                if (task?.id) {
-                    const nextParentId = typeof task.parentTaskId === 'string' && task.parentTaskId.trim().length > 0
-                        ? task.parentTaskId.trim()
-                        : null;
-                    const auditComment = buildRelationshipAuditComment(task.id, null, nextParentId);
-                    if (auditComment) {
-                        core.addComment(task.id, auditComment, 'ai', ACTIVE_WORKSPACE_ID);
-                    }
-                }
-                await notifyResourceMutation({
-                    taskIds: task?.id ? [task.id] : [],
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(task, null, 2) }],
-                };
-            }
-            case "update_task": {
-                const normalizedArgs = normalizeScheduleFieldAliases(args);
-                const { id, status, category, priority, type, approach, assignee, owner, complexity, ...updates } = normalizedArgs;
-                const existingTask = core.getTask(id, ACTIVE_WORKSPACE_ID);
-                if (!existingTask) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                // Safety Guard: Remove any fields that are set to our internal placeholder "%SAME%"
-                Object.keys(updates).forEach(key => {
-                    const value = updates[key];
-                    if (typeof value === 'string' && (value === '%SAME%' || value === '%SAME% ')) {
-                        delete updates[key];
-                    }
-                });
-                // Explicitly protect ID from being updated via the updates object
-                delete updates.id;
-                delete updates.owner;
-                const updateAssigneeInput = assignee ?? owner;
-                const normalized = {
-                    category: resolveStringOption('category', category, core.getCategories().map(c => ({ value: c.value, label: c.label }))),
-                    type: resolveStringOption('type', type, core.getTypes().map(t => ({ value: t.value, label: t.label }))),
-                    priority: resolveNumberOption('priority', priority, core.getPriorities().map(p => ({ value: p.value, label: p.label }))),
-                    approach: resolveStringOption('approach', approach, core.getApproaches().map(a => ({ value: a.value, label: a.label }))),
-                    assignee: resolveStringOption('assignee', updateAssigneeInput, [...ASSIGNEE_OPTIONS]),
-                    status: resolveStringOption('status', status, STATUS_OPTIONS),
-                    complexity: resolveNumberOption('complexity', complexity, COMPLEXITY_OPTIONS)
-                };
-                const finalUpdates = {
-                    ...updates,
-                    ...(normalized.category !== undefined ? { category: normalized.category } : {}),
-                    ...(normalized.type !== undefined ? { type: normalized.type } : {}),
-                    ...(normalized.priority !== undefined ? { priority: normalized.priority } : {}),
-                    ...(normalized.approach !== undefined ? { approach: normalized.approach } : {}),
-                    ...(normalized.assignee !== undefined ? { assignee: normalized.assignee } : {}),
-                    ...(normalized.complexity !== undefined ? { complexity: normalized.complexity } : {})
-                };
-                // If status is provided, update it. This NO LONGER auto-archives.
-                if (normalized.status) {
-                    finalUpdates.status = normalized.status;
-                }
-                const updated = core.updateTask(id, finalUpdates, ACTIVE_WORKSPACE_ID);
-                if (!updated) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                const previousParentId = typeof existingTask.parentTaskId === 'string' && existingTask.parentTaskId.trim().length > 0
-                    ? existingTask.parentTaskId.trim()
-                    : null;
-                const nextParentId = typeof updated.parentTaskId === 'string' && updated.parentTaskId.trim().length > 0
-                    ? updated.parentTaskId.trim()
-                    : null;
-                const auditComment = buildRelationshipAuditComment(id, previousParentId, nextParentId);
-                if (auditComment) {
-                    core.addComment(id, auditComment, 'ai', ACTIVE_WORKSPACE_ID);
-                }
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(updated, null, 2) }],
-                };
-            }
-            case "assign_task": {
-                const { id, assignee } = args;
-                if (!id || typeof id !== 'string')
-                    throw new Error('id is required');
-                const resolvedAssignee = resolveStringOption('assignee', assignee, [...ASSIGNEE_OPTIONS]);
-                if (!resolvedAssignee)
-                    throw new Error('assignee is required');
-                const updated = core.updateTask(id, { assignee: resolvedAssignee }, ACTIVE_WORKSPACE_ID);
-                if (!updated)
-                    throw new Error(`Task ${id} not found`);
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(updated, null, 2) }],
-                };
-            }
-            case "bulk_assign_tasks": {
-                const { ids, assignee } = args;
-                const list = Array.isArray(ids) ? ids : [];
-                if (list.length === 0)
-                    throw new Error('ids array is required');
-                const resolvedAssignee = resolveStringOption('assignee', assignee, [...ASSIGNEE_OPTIONS]);
-                if (!resolvedAssignee)
-                    throw new Error('assignee is required');
-                const updates = list.map((id) => ({ id, assignee: resolvedAssignee }));
-                const preview = core.bulkUpdateFieldsPreview(updates, ACTIVE_WORKSPACE_ID);
-                const changed = [];
-                const errors = [];
-                for (const skipped of preview.skipped) {
-                    if (skipped.statusCode >= 400) {
-                        errors.push({
-                            index: skipped.index,
-                            id: skipped.id,
-                            message: skipped.message,
-                            statusCode: skipped.statusCode,
-                            code: skipped.code
-                        });
-                    }
-                }
-                for (const item of preview.toApply) {
-                    const updated = core.updateTask(item.id, item.fields, ACTIVE_WORKSPACE_ID);
-                    if (!updated) {
-                        errors.push({ index: item.index, id: item.id, message: 'Task not found', statusCode: 404, code: 'TASK_NOT_FOUND' });
-                        continue;
-                    }
-                    changed.push({ id: updated.id, assignee: updated.assignee || 'unassigned' });
-                }
-                const summary = buildBatchSummary({
-                    operation: 'bulk-assign-tasks',
-                    total: list.length,
-                    succeeded: changed.length
-                });
-                await notifyResourceMutation({
-                    taskIds: list.filter((id) => typeof id === 'string'),
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: errors.length === 0,
-                                summary,
-                                results: {
-                                    assigned: changed,
-                                    preflight: {
-                                        deduped: preview.deduped,
-                                        skipped_noop: preview.skipped.filter((s) => s.code === 'NO_CHANGES' || s.code === 'DUPLICATE_SUPERSEDED').length
-                                    }
-                                },
-                                errors
-                            }, null, 2)
-                        }],
-                };
-            }
-            case "archive_task": {
-                const { id, status, reason } = args;
-                const isCancelled = status === 'cancelled';
-                const task = core.archiveTask(id, isCancelled, reason, ACTIVE_WORKSPACE_ID);
-                if (!task) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: `Task ${id} archived as ${status}` }],
-                };
-            }
-            case "list_skills": {
-                const skills = core.listSpecialists();
-                return {
-                    content: [{ type: "text", text: JSON.stringify(skills, null, 2) }],
-                };
-            }
-            case "get_config": {
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                categories: core.getCategories(),
-                                types: core.getTypes(),
-                                priorities: core.getPriorities(),
-                                approaches: core.getApproaches(),
-                                complexities: COMPLEXITY_OPTIONS
-                            }, null, 2)
-                        }],
-                };
-            }
-            case "update_categories": {
-                const { categories } = args;
-                core.updateCategories(categories);
-                await notifyResourceMutation({
-                    includeConfig: true,
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: "Categories updated" }],
-                };
-            }
-            case "add_comment": {
-                const { id, text, author } = args;
-                const validation = validateStructuredCommentForAdd(text);
-                if (!validation.ok) {
-                    throw new Error(validation.message);
-                }
-                const updated = core.addComment(id, text, author, ACTIVE_WORKSPACE_ID);
-                if (!updated) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                });
-                return {
-                    content: [{ type: "text", text: `Comment added to ${id}` }],
-                };
-            }
-            case "attach_context_file": {
-                const { id, path: inputPath, caption } = args;
-                if (!id)
-                    throw new Error("id is required");
-                if (!inputPath || typeof inputPath !== 'string')
-                    throw new Error("path is required");
-                const task = core.getTask(id, ACTIVE_WORKSPACE_ID);
-                if (!task) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                const trimmedPath = inputPath.trim();
-                if (!trimmedPath)
-                    throw new Error("path cannot be empty");
-                const now = new Date().toISOString();
-                const safeCaption = typeof caption === 'string' && caption.trim().length > 0
-                    ? caption.trim()
-                    : undefined;
-                const { projectRoot } = core.getPaths();
-                const attachment = (() => {
-                    if (isHttpUrl(trimmedPath)) {
-                        return {
-                            path: trimmedPath,
-                            caption: safeCaption || trimmedPath,
-                            timestamp: now
-                        };
-                    }
-                    const resolved = path.isAbsolute(trimmedPath)
-                        ? path.resolve(trimmedPath)
-                        : path.resolve(projectRoot, trimmedPath);
-                    if (!fs.existsSync(resolved)) {
-                        throw new Error(`File not found: ${trimmedPath}`);
-                    }
-                    const real = fs.realpathSync(resolved);
-                    if (!isWithinRoot(real, projectRoot)) {
-                        throw new Error("Linked file must be within project root");
-                    }
-                    if (!fs.statSync(real).isFile()) {
-                        throw new Error(`Path is not a file: ${trimmedPath}`);
-                    }
-                    const relativePath = toPosixPath(path.relative(projectRoot, real));
-                    if (relativePath.endsWith('.md')) {
-                        const content = fs.readFileSync(real, 'utf8');
-                        const validation = validateStructuredDocForAttach(relativePath, content);
-                        if (!validation.ok) {
-                            throw new Error(validation.message);
-                        }
-                    }
-                    return {
-                        path: `/api/taskforce/context-link?path=${encodeURIComponent(relativePath)}`,
-                        fsPath: relativePath,
-                        caption: safeCaption || path.basename(real),
-                        timestamp: now
-                    };
-                })();
-                const existing = Array.isArray(task.attachments)
-                    ? task.attachments
-                    : (Array.isArray(task.screenshots) ? task.screenshots : []);
-                const duplicate = existing.some((item) => {
-                    if (typeof item === 'string') {
-                        return item === attachment.path || (!!attachment.fsPath && item === attachment.fsPath);
-                    }
-                    if (!item || typeof item !== 'object')
-                        return false;
-                    if (item.path === attachment.path)
-                        return true;
-                    if (attachment.fsPath && item.fsPath === attachment.fsPath)
-                        return true;
-                    return false;
-                });
-                if (duplicate) {
-                    return {
-                        content: [{ type: "text", text: `Context file already attached to ${id}` }],
-                    };
-                }
-                const updated = core.updateTask(id, {
-                    attachments: [...existing, attachment]
-                }, ACTIVE_WORKSPACE_ID);
-                if (!updated) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                });
-                return {
-                    content: [{ type: "text", text: `Attached context file to ${id}\n${JSON.stringify(attachment, null, 2)}` }],
-                };
-            }
-            case "save_task_attachment": {
-                const { id, filename, content, sourcePath, caption, overwrite = false } = args;
-                if (!id)
-                    throw new Error("id is required");
-                if (!filename || typeof filename !== 'string')
-                    throw new Error("filename is required");
-                const hasContent = typeof content === 'string';
-                const hasSourcePath = typeof sourcePath === 'string' && sourcePath.trim().length > 0;
-                if (hasContent === hasSourcePath) {
-                    throw new Error("Provide exactly one of: content or sourcePath");
-                }
-                const task = core.getTask(id, ACTIVE_WORKSPACE_ID);
-                if (!task)
-                    throw new Error(`Task ${id} not found`);
-                const now = new Date().toISOString();
-                const safeCaption = typeof caption === 'string' && caption.trim().length > 0
-                    ? caption.trim()
-                    : undefined;
-                const { projectRoot, taskDataDir } = core.getPaths();
-                const taskPathSegment = sanitizeTaskIdForPath(id);
-                const attachmentsDir = path.join(taskDataDir, taskPathSegment, 'attachments');
-                fs.mkdirSync(attachmentsDir, { recursive: true });
-                let safeFilename = sanitizeFilenameForPath(filename);
-                let destinationPath = path.join(attachmentsDir, safeFilename);
-                if (!overwrite) {
-                    destinationPath = nextAvailablePath(destinationPath);
-                    safeFilename = path.basename(destinationPath);
-                }
-                if (hasContent) {
-                    fs.writeFileSync(destinationPath, content, 'utf8');
-                }
-                else {
-                    const trimmedSource = sourcePath.trim();
-                    const sourceResolved = path.isAbsolute(trimmedSource)
-                        ? path.resolve(trimmedSource)
-                        : path.resolve(projectRoot, trimmedSource);
-                    if (!fs.existsSync(sourceResolved)) {
-                        throw new Error(`File not found: ${trimmedSource}`);
-                    }
-                    const sourceReal = fs.realpathSync(sourceResolved);
-                    if (!isWithinRoot(sourceReal, projectRoot)) {
-                        throw new Error("sourcePath must be within project root");
-                    }
-                    if (!fs.statSync(sourceReal).isFile()) {
-                        throw new Error(`Path is not a file: ${trimmedSource}`);
-                    }
-                    fs.copyFileSync(sourceReal, destinationPath);
-                }
-                const relativePath = toPosixPath(path.relative(projectRoot, destinationPath));
-                if (relativePath.endsWith('.md')) {
-                    const fileContent = fs.readFileSync(destinationPath, 'utf8');
-                    const validation = validateStructuredDocForAttach(relativePath, fileContent);
-                    if (!validation.ok) {
-                        throw new Error(validation.message);
-                    }
-                }
-                const attachment = {
-                    path: `/api/taskforce/context-link?path=${encodeURIComponent(relativePath)}`,
-                    fsPath: relativePath,
-                    caption: safeCaption || safeFilename,
-                    timestamp: now
-                };
-                const existing = Array.isArray(task.attachments)
-                    ? task.attachments
-                    : (Array.isArray(task.screenshots) ? task.screenshots : []);
-                const duplicate = existing.some((item) => {
-                    if (typeof item === 'string') {
-                        return item === attachment.path || item === attachment.fsPath;
-                    }
-                    if (!item || typeof item !== 'object')
-                        return false;
-                    if (item.path === attachment.path)
-                        return true;
-                    if (item.fsPath === attachment.fsPath)
-                        return true;
-                    return false;
-                });
-                if (duplicate) {
-                    return {
-                        content: [{ type: "text", text: `Task attachment saved for ${id}\n${JSON.stringify(attachment, null, 2)}\nAlready attached.` }],
-                    };
-                }
-                const updated = core.updateTask(id, {
-                    attachments: [...existing, attachment]
-                }, ACTIVE_WORKSPACE_ID);
-                if (!updated) {
-                    throw new Error(`Task ${id} not found`);
-                }
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                });
-                return {
-                    content: [{ type: "text", text: `Task attachment saved and attached to ${id}\n${JSON.stringify(attachment, null, 2)}` }],
-                };
-            }
-            case "list_archive": {
-                const { format = "markdown" } = args;
-                const archive = core.listArchive(ACTIVE_WORKSPACE_ID);
-                if (format === "json") {
-                    return {
-                        content: [{ type: "text", text: JSON.stringify(archive.archived, null, 2) }],
-                    };
-                }
-                return {
-                    content: [{ type: "text", text: renderTaskTable(archive.archived) }],
-                };
-            }
-            case "unarchive_task": {
-                const { id } = args;
-                const task = core.unarchiveTask(id, ACTIVE_WORKSPACE_ID);
-                if (!task) {
-                    throw new Error(`Task ${id} not found in archive`);
-                }
-                await notifyResourceMutation({
-                    taskIds: [id],
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: `Task ${id} unarchived` }],
-                };
-            }
-            case "bulk_archive": {
-                const { ids, status = "done" } = args;
-                const isCancellation = status === "cancelled";
-                const list = Array.isArray(ids) ? ids : [];
-                const archived = [];
-                const errors = [];
-                for (let i = 0; i < list.length; i++) {
-                    const id = list[i];
-                    try {
-                        const item = core.archiveTask(id, isCancellation, undefined, ACTIVE_WORKSPACE_ID);
-                        if (!item) {
-                            errors.push({ index: i, id, message: 'Task not found', statusCode: 404, code: 'TASK_NOT_FOUND' });
-                            continue;
-                        }
-                        archived.push(item);
-                    }
-                    catch (error) {
-                        errors.push({
-                            index: i,
-                            id,
-                            message: error?.message || 'Failed to archive task',
-                            statusCode: Number.isFinite(Number(error?.statusCode)) ? Number(error.statusCode) : 400,
-                            code: typeof error?.code === 'string' ? error.code : undefined
-                        });
-                    }
-                }
-                const summary = buildBatchSummary({
-                    operation: 'bulk-archive',
-                    total: list.length,
-                    succeeded: archived.length
-                });
-                await notifyResourceMutation({
-                    taskIds: list,
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: errors.length === 0,
-                                summary,
-                                results: { archived },
-                                errors
-                            }, null, 2)
-                        }],
-                };
-            }
-            case "update_types": {
-                const { types } = args;
-                core.updateTypes(types);
-                await notifyResourceMutation({
-                    includeConfig: true,
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: "Task types updated" }],
-                };
-            }
-            case "bulk_update_type": {
-                const { fromType, toType } = args;
-                const count = core.bulkUpdateType(fromType, toType, ACTIVE_WORKSPACE_ID);
-                await notifyResourceMutation({
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: `Updated ${count} items from ${fromType} to ${toType}` }],
-                };
-            }
-            case "bulk_update_fields": {
-                const { updates } = args;
-                const list = Array.isArray(updates) ? updates : [];
-                // Validate all updates before applying
-                for (const update of list) {
-                    const assigneeInput = update.assignee ?? update.owner;
-                    update.category = resolveStringOption('category', update.category, core.getCategories().map(c => ({ value: c.value, label: c.label })));
-                    update.type = resolveStringOption('type', update.type, core.getTypes().map(t => ({ value: t.value, label: t.label })));
-                    update.priority = resolveNumberOption('priority', update.priority, core.getPriorities().map(p => ({ value: p.value, label: p.label })));
-                    update.approach = resolveStringOption('approach', update.approach, core.getApproaches().map(a => ({ value: a.value, label: a.label })));
-                    update.assignee = resolveStringOption('assignee', assigneeInput, [...ASSIGNEE_OPTIONS]);
-                    delete update.owner;
-                    update.status = resolveStringOption('status', update.status, STATUS_OPTIONS);
-                    update.complexity = resolveNumberOption('complexity', update.complexity, COMPLEXITY_OPTIONS);
-                }
-                const preview = core.bulkUpdateFieldsPreview(list, ACTIVE_WORKSPACE_ID);
-                const changed = [];
-                const errors = [];
-                for (const skipped of preview.skipped) {
-                    if (skipped.statusCode >= 400) {
-                        errors.push({
-                            index: skipped.index,
-                            id: skipped.id,
-                            message: skipped.message,
-                            statusCode: skipped.statusCode,
-                            code: skipped.code
-                        });
-                    }
-                }
-                for (const item of preview.toApply) {
-                    const updated = core.updateTask(item.id, item.fields, ACTIVE_WORKSPACE_ID);
-                    if (!updated) {
-                        errors.push({ index: item.index, id: item.id, message: 'Task not found', statusCode: 404, code: 'TASK_NOT_FOUND' });
-                        continue;
-                    }
-                    changed.push({ id: item.id, fields: item.changedFields });
-                }
-                const summary = buildBatchSummary({
-                    operation: 'bulk-update-fields',
-                    total: list.length,
-                    succeeded: changed.length
-                });
-                await notifyResourceMutation({
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: errors.length === 0,
-                                summary,
-                                results: {
-                                    changes: changed,
-                                    preflight: {
-                                        deduped: preview.deduped,
-                                        skipped_noop: preview.skipped.filter((s) => s.code === 'NO_CHANGES' || s.code === 'DUPLICATE_SUPERSEDED').length,
-                                        by_field: preview.byField,
-                                        priority_before: preview.priorityBefore,
-                                        priority_after: preview.priorityAfter
-                                    }
-                                },
-                                errors
-                            }, null, 2)
-                        }],
-                };
-            }
-            case "export_resources": {
-                const { type, path, variables, environment } = args;
-                const count = core.exportResources(type, path, variables, environment);
-                return {
-                    content: [{ type: "text", text: `Exported ${count} ${type} to ${path}` }],
-                };
-            }
-            case "get_paths": {
-                const paths = core.getPaths();
-                return {
-                    content: [{ type: "text", text: JSON.stringify(paths, null, 2) }],
-                };
-            }
-            case "update_priorities": {
-                const { priorities } = args;
-                core.updatePriorities(priorities);
-                await notifyResourceMutation({
-                    includeConfig: true,
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: "Priorities updated" }],
-                };
-            }
-            case "update_approaches": {
-                const { approaches } = args;
-                core.updateApproaches(approaches);
-                await notifyResourceMutation({
-                    includeConfig: true,
-                    includeTasks: true,
-                    includeStats: true,
-                });
-                return {
-                    content: [{ type: "text", text: "Approaches updated" }],
-                };
-            }
-            case "get_stats": {
-                const stats = core.getStats(ACTIVE_WORKSPACE_ID);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(stats, null, 2) }],
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error: ${error.message}` }],
-            isError: true,
-        };
-    }
-});
-/**
- * Start Server
- */
-const transport = new StdioServerTransport();
-await server.connect(transport);
+import { startTaskforceMcpStdioServer } from './runtime.js';
+await startTaskforceMcpStdioServer();