@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/server/routes/tasks.js

@@ -0,0 +1,1252 @@
+/**
+ * Task route module.
+ *
+ * Handles all task CRUD, scheduling, bulk operations, initiative templates,
+ * taxonomy management (categories/types/priorities/custom taxonomies),
+ * workflow option endpoints, configuration, UI state, health, version,
+ * and data-version endpoints.
+ *
+ * Routes registered here (lines from the original routes.ts extraction):
+ *   GET  /api/taskforce/config
+ *   POST /api/taskforce/config
+ *   POST /api/taskforce/global-settings
+ *   POST /api/taskforce/workspace-profile
+ *   GET  /api/taskforce/ui-state
+ *   POST /api/taskforce/ui-state
+ *   GET  /api/taskforce/tasks
+ *   GET  /api/taskforce/deleted
+ *   GET  /api/taskforce/deleted/:id
+ *   GET  /api/taskforce/schedule
+ *   GET  /api/taskforce/data-version
+ *   GET  /api/taskforce/health
+ *   GET  /api/taskforce/version
+ *   POST /api/taskforce/task
+ *   PATCH /api/taskforce/task/:id
+ *   PATCH /api/taskforce/task/:id/schedule
+ *   POST /api/taskforce/schedule/reorder
+ *   GET  /api/taskforce/archive
+ *   POST /api/taskforce/task/:id/complete
+ *   POST /api/taskforce/task/:id/cancel
+ *   DELETE /api/taskforce/task/:id
+ *   POST /api/taskforce/deleted/:id/restore
+ *   POST /api/taskforce/task/:id/comment
+ *   POST /api/taskforce/task/:id/unarchive
+ *   POST /api/taskforce/bulk-create
+ *   POST /api/taskforce/bulk-archive
+ *   POST /api/taskforce/bulk-update-fields
+ *   POST /api/taskforce/bulk-update-fields/preview
+ *   GET  /api/taskforce/initiative-templates
+ *   POST /api/taskforce/initiative-templates/create
+ *   GET  /api/taskforce/taxonomy-library
+ *   GET  /api/taskforce/categories
+ *   POST /api/taskforce/categories
+ *   GET  /api/taskforce/types
+ *   POST /api/taskforce/types
+ *   GET  /api/taskforce/priorities
+ *   POST /api/taskforce/priorities
+ *   GET  /api/taskforce/approaches
+ *   POST /api/taskforce/approaches
+ *   GET  /api/taskforce/taxonomies
+ *   POST /api/taskforce/taxonomies
+ */
+import { TaskforceRuleError } from '../../core/Taskforce.js';
+import { toPublicObjectStorageConfig } from '../../storage/objectStorage.js';
+import { getRuntimeCapabilities } from '../../runtime/capabilities.js';
+import { resolveBuildInfo } from '../buildInfo.js';
+import { resolveRealtimeSyncFlag } from '../../sync/realtimeFeature.js';
+import { parseJsonBody } from '../routes.js';
+import { resolveErrorStatusCode, requestHeader, requestRuntimeMode } from './shared.js';
+import { listBuiltInCustomTaxonomyLibraryPacks } from '../../shared/customTaxonomyLibrary.js';
+import { listBuiltInTaxonomyLibraryPacks } from '../../shared/taxonomyLibrary.js';
+// === SECTION: Registration ===
+export function registerTaskRoutes(deps) {
+    const { addRoute, core, context, requestWorkspaceId, ensureAppAccess, resolveEffectiveObjectStorageConfig, buildBatchSummary, CLOUD_SAFE_CONFIG_PATHS, } = deps;
+    // === SECTION: Config and settings ===
+    // GET /api/taskforce/config - Get current configuration
+    addRoute('GET', '/api/taskforce/config', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const requestUserId = String(res.req?.headers?.['x-taskforce-user-id'] || 'anonymous');
+        const projectConfig = core.getConfig(workspaceId, requestUserId);
+        const paths = core.getPaths();
+        const globalSettings = core.getGlobalSettings();
+        const effectiveTheme = core.getEffectiveTheme(workspaceId, requestUserId);
+        const themeUseGlobalDefault = !core.hasProjectThemeOverride(workspaceId, requestUserId);
+        const jsonBackupUseGlobalDefault = !core.hasProjectJsonBackupOverride(workspaceId, requestUserId);
+        const mode = res.req?.headers?.['x-taskforce-mode'] || 'standalone';
+        const runtimeHeader = String(res.req?.headers?.['x-taskforce-runtime-mode'] || '').toLowerCase();
+        const runtimeMode = runtimeHeader === 'cloud' ? 'cloud' : 'local';
+        const authRequiredForApi = String(res.req?.headers?.['x-taskforce-auth-required'] || '').toLowerCase() === 'true';
+        const requestRole = String(res.req?.headers?.['x-taskforce-role'] || 'member');
+        const runtimeCapabilities = getRuntimeCapabilities(runtimeMode);
+        const setupState = core.getSetupState(workspaceId, runtimeMode);
+        const realtimeSyncFlag = resolveRealtimeSyncFlag(process.env, globalSettings.realtimeSyncEnabled);
+        const workspaceDisplayName = String(setupState.workspace?.name || '').trim();
+        const resolvedProjectName = workspaceDisplayName
+            || (runtimeMode === 'cloud' ? '' : paths.projectName);
+        const resolvedPaths = runtimeMode === 'cloud'
+            ? CLOUD_SAFE_CONFIG_PATHS
+            : paths;
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            ...projectConfig,
+            theme: effectiveTheme,
+            shortcut: globalSettings.shortcut,
+            schedulePreferences: globalSettings.schedulePreferences,
+            globalTheme: globalSettings.theme ?? effectiveTheme,
+            themeUseGlobalDefault,
+            jsonBackupEnabled: runtimeMode === 'cloud' ? false : core.getJsonBackupEnabled(workspaceId, requestUserId),
+            globalJsonBackupEnabled: runtimeMode === 'cloud'
+                ? false
+                : (typeof globalSettings.jsonBackupEnabled === 'boolean'
+                    ? globalSettings.jsonBackupEnabled
+                    : false),
+            jsonBackupUseGlobalDefault: runtimeMode === 'cloud' ? false : jsonBackupUseGlobalDefault,
+            ...resolvedPaths,
+            hostRoot: runtimeMode === 'cloud' ? '' : String(projectConfig?.hostRoot || ''),
+            projectName: resolvedProjectName,
+            storagePath: runtimeMode === 'cloud' ? '' : paths.basePath,
+            mode,
+            runtimeMode,
+            runtimeCapabilities,
+            authRequiredForApi,
+            role: requestRole,
+            workspaceId,
+            userId: requestUserId,
+            setupState,
+            objectStorage: toPublicObjectStorageConfig(resolveEffectiveObjectStorageConfig()),
+            realtimeSyncEnabled: realtimeSyncFlag.enabled,
+            realtimeSyncFlagSource: realtimeSyncFlag.source
+        }));
+    });
+    // POST /api/taskforce/global-settings - Update global preferences
+    addRoute('POST', '/api/taskforce/global-settings', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            core.updateGlobalSettings(body);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false }));
+        }
+    });
+    // POST /api/taskforce/workspace-profile - Update workspace name/description
+    addRoute('POST', '/api/taskforce/workspace-profile', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const name = String(body?.name || '').trim();
+        const description = typeof body?.description === 'string' ? body.description : undefined;
+        const slug = typeof body?.slug === 'string' ? body.slug : undefined;
+        const runtimeHeader = String((req.headers['x-taskforce-runtime-mode'] || '')).toLowerCase();
+        const isLocalRuntime = runtimeHeader === 'local';
+        const allowCreate = body?.allowCreate === true;
+        const explicitWorkspaceId = typeof body?.workspaceId === 'string'
+            ? body.workspaceId.trim()
+            : '';
+        const headerWorkspaceId = requestWorkspaceId(req);
+        const incomingWorkspaceId = String(explicitWorkspaceId
+            || ((isLocalRuntime && allowCreate && !explicitWorkspaceId) ? '' : headerWorkspaceId)).trim() || 'default';
+        try {
+            const workspaceExists = Boolean(core.getWorkspaceProfile(incomingWorkspaceId));
+            const shouldCreateWorkspace = Boolean(name
+                && (incomingWorkspaceId === 'default' || !workspaceExists)
+                && (isLocalRuntime || allowCreate));
+            const workspace = shouldCreateWorkspace
+                ? core.createWorkspace({
+                    workspaceId: incomingWorkspaceId === 'default' ? undefined : incomingWorkspaceId,
+                    name,
+                    description,
+                    slug
+                })
+                : core.updateWorkspaceProfile(incomingWorkspaceId, { name, description, slug });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, workspace }));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: String(error?.message || 'Failed to update workspace profile'), code: error?.code }));
+        }
+    });
+    // GET /api/taskforce/ui-state - Read persisted app UI state
+    addRoute('GET', '/api/taskforce/ui-state', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const url = new URL(req.url || '/', 'http://localhost');
+            const requestedWorkspaceId = String(url.searchParams.get('workspaceId') || '').trim();
+            let workspaceId = requestWorkspaceId(req);
+            if (requestedWorkspaceId && requestRuntimeMode(req) === 'local') {
+                workspaceId = requestedWorkspaceId;
+            }
+            const userId = requestHeader(req, 'x-taskforce-user-id', 'anonymous');
+            const stateKey = String(url.searchParams.get('key') || '').trim() || 'default';
+            const state = core.getUiState(workspaceId, userId, stateKey);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, state: state || {} }));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: String(error?.message || 'Failed to read UI state') }));
+        }
+    });
+    // POST /api/taskforce/ui-state - Merge persisted app UI state
+    addRoute('POST', '/api/taskforce/ui-state', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const requestedWorkspaceId = String(body?.workspaceId || '').trim();
+            let workspaceId = requestWorkspaceId(req);
+            if (requestedWorkspaceId && requestRuntimeMode(req) === 'local') {
+                workspaceId = requestedWorkspaceId;
+            }
+            const userId = requestHeader(req, 'x-taskforce-user-id', 'anonymous');
+            const stateKey = String(body?.stateKey || body?.key || '').trim() || 'default';
+            const patch = body?.patch && typeof body.patch === 'object'
+                ? body.patch
+                : body?.state && typeof body.state === 'object'
+                    ? body.state
+                    : {};
+            core.updateUiState(workspaceId, userId, { stateKey, patch });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: String(error?.message || 'Failed to merge UI state') }));
+        }
+    });
+    // POST /api/taskforce/config - Update configuration
+    addRoute('POST', '/api/taskforce/config', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const userId = requestHeader(req, 'x-taskforce-user-id', 'anonymous');
+            core.updateConfig(body, workspaceId, userId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false }));
+        }
+    });
+    // === SECTION: Health and version ===
+    // GET /api/taskforce/tasks - List all active tasks
+    addRoute('GET', '/api/taskforce/tasks', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const data = core.listTasks(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    });
+    const handleListDeletedTasks = async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const data = core.listDeletedTasks(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    // GET /api/taskforce/deleted - List deleted tasks
+    addRoute('GET', '/api/taskforce/deleted', handleListDeletedTasks);
+    addRoute('GET', '/api/taskforce/trash', handleListDeletedTasks);
+    const handleGetDeletedTask = async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const deletedTask = core.getDeletedTask(params.id, workspaceId);
+        if (!deletedTask) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Deleted task not found' }));
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(deletedTask));
+    };
+    // GET /api/taskforce/deleted/:id - Get one deleted task detail
+    addRoute('GET', '/api/taskforce/deleted/:id', handleGetDeletedTask);
+    addRoute('GET', '/api/taskforce/trash/:id', handleGetDeletedTask);
+    // GET /api/taskforce/schedule - Get schedule board for a week
+    addRoute('GET', '/api/taskforce/schedule', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const requestUrl = new URL(req.url || '', 'http://localhost');
+            const week = requestUrl.searchParams.get('week');
+            const showWeekendsRaw = requestUrl.searchParams.get('showWeekends');
+            const showWeekends = showWeekendsRaw === '1' || showWeekendsRaw === 'true';
+            if (!week) {
+                const err = new Error('Missing required query parameter: week');
+                err.statusCode = 400;
+                throw err;
+            }
+            const workspaceId = requestWorkspaceId(req);
+            const board = core.getScheduleBoard(week, showWeekends, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(board));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to load schedule board';
+            const errorCode = error instanceof TaskforceRuleError ? error.code : error?.code;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message, code: errorCode }));
+        }
+    });
+    // GET /api/taskforce/data-version - Lightweight DB change signal
+    addRoute('GET', '/api/taskforce/data-version', async (req, res) => {
+        const dataVersion = core.getDataVersion();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ dataVersion }));
+    });
+    // GET /api/taskforce/health - Lightweight readiness signal for API + DB
+    addRoute('GET', '/api/taskforce/health', async (req, res) => {
+        const healthy = core.isDatabaseHealthy();
+        const payload = {
+            ok: healthy,
+            database: {
+                provider: core.getDatabaseProvider(),
+                healthy
+            }
+        };
+        res.writeHead(healthy ? 200 : 503, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(payload));
+    });
+    // GET /api/taskforce/version - Build/runtime identity for traceability
+    addRoute('GET', '/api/taskforce/version', async (_req, res) => {
+        const build = resolveBuildInfo();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, build }));
+    });
+    // === SECTION: Task CRUD ===
+    // POST /api/taskforce/task - Create new task
+    addRoute('POST', '/api/taskforce/task', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const { validate_only = false, ...taskInput } = body || {};
+        if (validate_only === true) {
+            const workspaceId = requestWorkspaceId(req);
+            const result = core.bulkCreateTasks([taskInput], {
+                atomic: true,
+                validateOnly: true,
+                workspaceId
+            });
+            const hasErrors = result.errors.length > 0;
+            const failureStatus = hasErrors
+                ? resolveErrorStatusCode({ statusCode: result.errors[0]?.statusCode }, 400)
+                : 400;
+            const statusCode = hasErrors ? failureStatus : 200;
+            const validationSummary = {
+                success: !hasErrors,
+                ...result,
+                needs_confirmation: !!result.errors.find((e) => e?.code === 'TAXONOMY_NEEDS_CONFIRMATION')
+            };
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(validationSummary));
+            return;
+        }
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const task = core.createTask(taskInput, { workspaceId, actorRef: 'user' });
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(task));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to create task';
+            const errorCode = error instanceof TaskforceRuleError ? error.code : error?.code;
+            const errorDetails = error instanceof TaskforceRuleError ? error.details : error?.details;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: message,
+                code: errorCode,
+                details: errorDetails,
+                needs_confirmation: errorCode === 'TAXONOMY_NEEDS_CONFIRMATION'
+            }));
+        }
+    });
+    // PATCH /api/taskforce/task/:id - Update a task
+    addRoute('PATCH', '/api/taskforce/task/:id', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const updated = core.updateTask(params.id, body, workspaceId, { actorRef: 'user' });
+            if (!updated) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Task not found' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(updated));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to update task';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    // GET /api/taskforce/task/:id/checklist - Read structured checklist items for one task
+    addRoute('GET', '/api/taskforce/task/:id/checklist', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const task = core.getTask(params.id, workspaceId);
+        if (!task) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Task not found' }));
+            return;
+        }
+        const items = core.listChecklistItems(params.id, workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(items));
+    });
+    // PUT /api/taskforce/task/:id/checklist - Replace structured checklist items for one task
+    addRoute('PUT', '/api/taskforce/task/:id/checklist', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const items = Array.isArray(body?.items) ? body.items : [];
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const task = core.getTask(params.id, workspaceId);
+            if (!task) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Task not found' }));
+                return;
+            }
+            const updated = core.replaceChecklistItems(params.id, items, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(updated));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to update checklist';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    // GET /api/taskforce/initiatives - List initiatives
+    addRoute('GET', '/api/taskforce/initiatives', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const data = core.listInitiatives(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    });
+    // POST /api/taskforce/initiative - Create initiative
+    addRoute('POST', '/api/taskforce/initiative', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const initiative = core.createInitiative(body || {}, workspaceId);
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(initiative));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to create initiative';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    // GET /api/taskforce/initiative/:id - Read one initiative
+    addRoute('GET', '/api/taskforce/initiative/:id', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const initiative = core.getInitiative(params.id, workspaceId);
+        if (!initiative) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Initiative not found' }));
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(initiative));
+    });
+    // PATCH /api/taskforce/initiative/:id - Update initiative
+    addRoute('PATCH', '/api/taskforce/initiative/:id', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const updated = core.updateInitiative(params.id, body || {}, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(updated));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to update initiative';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    addRoute('POST', '/api/taskforce/initiative/:id/archive', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const archived = core.archiveInitiative(params.id, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(archived));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to archive initiative';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    addRoute('POST', '/api/taskforce/initiative/:id/unarchive', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const restored = core.unarchiveInitiative(params.id, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(restored));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to unarchive initiative';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    // GET /api/taskforce/workstreams - List workstreams
+    addRoute('GET', '/api/taskforce/workstreams', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const data = core.listWorkstreams(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    });
+    // POST /api/taskforce/workstream - Create workstream
+    addRoute('POST', '/api/taskforce/workstream', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const workstream = core.createWorkstream(body || {}, workspaceId);
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(workstream));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to create workstream';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    // GET /api/taskforce/workstream/:id - Read one workstream
+    addRoute('GET', '/api/taskforce/workstream/:id', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const workstream = core.getWorkstream(params.id, workspaceId);
+        if (!workstream) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Workstream not found' }));
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(workstream));
+    });
+    // PATCH /api/taskforce/workstream/:id - Update workstream
+    addRoute('PATCH', '/api/taskforce/workstream/:id', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const updated = core.updateWorkstream(params.id, body || {}, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(updated));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to update workstream';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    addRoute('POST', '/api/taskforce/workstream/:id/archive', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const archived = core.archiveWorkstream(params.id, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(archived));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to archive workstream';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    addRoute('POST', '/api/taskforce/workstream/:id/unarchive', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const restored = core.unarchiveWorkstream(params.id, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(restored));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to unarchive workstream';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    // PATCH /api/taskforce/task/:id/schedule - Update schedule fields for one task
+    addRoute('PATCH', '/api/taskforce/task/:id/schedule', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const result = core.updateTaskSchedule(params.id, {
+                scheduledDate: body?.scheduledDate ?? null,
+                orderInDay: body?.orderInDay
+            }, workspaceId);
+            if (!result) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Task not found' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(result));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to update task schedule';
+            const errorCode = error instanceof TaskforceRuleError ? error.code : error?.code;
+            const errorDetails = error instanceof TaskforceRuleError ? error.details : error?.details;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message, code: errorCode, details: errorDetails }));
+        }
+    });
+    // POST /api/taskforce/schedule/reorder - Reorder/move multiple scheduled tasks
+    addRoute('POST', '/api/taskforce/schedule/reorder', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const moves = Array.isArray(body?.moves) ? body.moves : [];
+            const workspaceId = requestWorkspaceId(req);
+            const result = core.reorderScheduledTasks(moves, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(result));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to reorder scheduled tasks';
+            const errorCode = error instanceof TaskforceRuleError ? error.code : error?.code;
+            const errorDetails = error instanceof TaskforceRuleError ? error.details : error?.details;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message, code: errorCode, details: errorDetails }));
+        }
+    });
+    // GET /api/taskforce/archive - List all archived tasks
+    addRoute('GET', '/api/taskforce/archive', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const data = core.listArchive(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    });
+    // POST /api/taskforce/task/:id/complete - Archive as complete
+    addRoute('POST', '/api/taskforce/task/:id/complete', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const archived = core.archiveTask(params.id, false, undefined, workspaceId, { actorRef: 'user' });
+            if (!archived) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Task not found' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(archived));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to archive task';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    // POST /api/taskforce/task/:id/cancel - Archive as cancelled
+    addRoute('POST', '/api/taskforce/task/:id/cancel', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const reason = body.reason || 'Cancelled';
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const archived = core.archiveTask(params.id, true, reason, workspaceId, { actorRef: 'user' });
+            if (!archived) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Task not found' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(archived));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to cancel task';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    // DELETE /api/taskforce/task/:id - Delete a task
+    addRoute('DELETE', '/api/taskforce/task/:id', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const deleted = core.softDeleteTask(params.id, workspaceId, { actorRef: 'user', source: 'ui' });
+            if (!deleted) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Task not found' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, deleted }));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to delete task';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    });
+    const handleRestoreDeletedTaskRoute = async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const restored = core.restoreDeletedTask(params.id, workspaceId, { actorRef: 'user' });
+            if (!restored) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Deleted task not found' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(restored));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to restore deleted task';
+            const errorCode = error instanceof TaskforceRuleError ? error.code : error?.code;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message, code: errorCode }));
+        }
+    };
+    // POST /api/taskforce/deleted/:id/restore - Restore a deleted task
+    addRoute('POST', '/api/taskforce/deleted/:id/restore', handleRestoreDeletedTaskRoute);
+    addRoute('POST', '/api/taskforce/trash/:id/restore', handleRestoreDeletedTaskRoute);
+    const handlePermanentlyDeleteDeletedTaskRoute = async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const deleted = core.permanentlyDeleteDeletedTask(params.id, workspaceId);
+            if (!deleted) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Deleted task not found' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to permanently delete deleted task';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    };
+    // DELETE /api/taskforce/deleted/:id - Permanently delete a deleted task
+    addRoute('DELETE', '/api/taskforce/deleted/:id', handlePermanentlyDeleteDeletedTaskRoute);
+    addRoute('DELETE', '/api/taskforce/trash/:id', handlePermanentlyDeleteDeletedTaskRoute);
+    const handleEmptyDeletedTasks = async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const deleted = core.permanentlyDeleteAllDeletedTasks(workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, deleted }));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to permanently delete deleted tasks';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message }));
+        }
+    };
+    // POST /api/taskforce/deleted/empty - Permanently delete all deleted tasks in the workspace
+    addRoute('POST', '/api/taskforce/deleted/empty', handleEmptyDeletedTasks);
+    addRoute('POST', '/api/taskforce/trash/empty', handleEmptyDeletedTasks);
+    // POST /api/taskforce/task/:id/comment - Add a comment to a task
+    addRoute('POST', '/api/taskforce/task/:id/comment', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const { text, author = 'user' } = body;
+        if (!text) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Comment text is required' }));
+            return;
+        }
+        const workspaceId = requestWorkspaceId(req);
+        const updated = core.addComment(params.id, text, author, workspaceId, { actorRef: author || 'user' });
+        if (!updated) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Task not found' }));
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(updated));
+    });
+    // POST /api/taskforce/task/:id/unarchive - Restore an archived task
+    addRoute('POST', '/api/taskforce/task/:id/unarchive', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const restored = core.unarchiveTask(params.id, workspaceId, { actorRef: 'user' });
+        if (!restored) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Archived task not found' }));
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(restored));
+    });
+    // === SECTION: Bulk operations ===
+    // POST /api/taskforce/bulk-create - Create multiple tasks with optional atomic + validate-only behavior
+    addRoute('POST', '/api/taskforce/bulk-create', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const { tasks, atomic = true, validate_only = false } = body;
+        if (!Array.isArray(tasks) || tasks.length === 0) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'tasks array is required' }));
+            return;
+        }
+        const workspaceId = requestWorkspaceId(req);
+        const result = core.bulkCreateTasks(tasks, {
+            atomic: atomic !== false,
+            validateOnly: validate_only === true,
+            workspaceId
+        });
+        const hasErrors = result.errors.length > 0;
+        const succeeded = validate_only ? (hasErrors ? 0 : result.total) : result.created.length;
+        const summary = buildBatchSummary({
+            operation: 'bulk-create',
+            total: result.total,
+            succeeded,
+            atomic: result.atomic,
+            validateOnly: result.validateOnly
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: !hasErrors,
+            needs_confirmation: !!result.errors.find((e) => e?.code === 'TAXONOMY_NEEDS_CONFIRMATION'),
+            summary,
+            results: {
+                created: result.created
+            },
+            errors: result.errors
+        }));
+    });
+    // POST /api/taskforce/bulk-archive - Archive multiple tasks at once
+    addRoute('POST', '/api/taskforce/bulk-archive', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const { ids, status = 'done' } = body;
+        if (!ids || !Array.isArray(ids) || ids.length === 0) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'ids array is required' }));
+            return;
+        }
+        const isCancellation = status === 'cancelled';
+        const archived = [];
+        const errors = [];
+        for (let i = 0; i < ids.length; i++) {
+            const taskId = ids[i];
+            try {
+                const workspaceId = requestWorkspaceId(req);
+                const item = core.archiveTask(taskId, isCancellation, undefined, workspaceId);
+                if (!item) {
+                    errors.push({ index: i, id: taskId, message: 'Task not found', statusCode: 404, code: 'TASK_NOT_FOUND' });
+                    continue;
+                }
+                archived.push(item);
+            }
+            catch (error) {
+                errors.push({
+                    index: i,
+                    id: taskId,
+                    message: error instanceof Error ? error.message : 'Failed to archive task',
+                    statusCode: resolveErrorStatusCode(error, 400),
+                    code: error instanceof TaskforceRuleError ? error.code : error?.code
+                });
+            }
+        }
+        const summary = buildBatchSummary({
+            operation: 'bulk-archive',
+            total: ids.length,
+            succeeded: archived.length
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: errors.length === 0,
+            summary,
+            results: {
+                archived
+            },
+            errors
+        }));
+    });
+    // POST /api/taskforce/bulk-update-fields - Batch update multiple tasks
+    addRoute('POST', '/api/taskforce/bulk-update-fields', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const { updates } = body;
+        if (!updates || !Array.isArray(updates) || updates.length === 0) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'updates array is required' }));
+            return;
+        }
+        const workspaceId = requestWorkspaceId(req);
+        const preview = core.bulkUpdateFieldsPreview(updates, workspaceId);
+        const results = [];
+        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 { id, fields } = item;
+            try {
+                const updated = core.updateTask(id, fields, workspaceId);
+                if (updated) {
+                    results.push(updated);
+                }
+                else {
+                    errors.push({ index: item.index, id, message: 'Task not found', statusCode: 404, code: 'TASK_NOT_FOUND' });
+                }
+            }
+            catch (error) {
+                errors.push({
+                    index: item.index,
+                    id,
+                    message: error instanceof Error ? error.message : 'Failed to update task',
+                    statusCode: resolveErrorStatusCode(error, 400),
+                    code: error instanceof TaskforceRuleError ? error.code : error?.code
+                });
+            }
+        }
+        const summary = buildBatchSummary({
+            operation: 'bulk-update-fields',
+            total: updates.length,
+            succeeded: results.length
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: errors.length === 0,
+            summary,
+            results: {
+                updated: results,
+                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
+        }));
+    });
+    // POST /api/taskforce/bulk-update-fields/preview - Dry-run summary for bulk updates
+    addRoute('POST', '/api/taskforce/bulk-update-fields/preview', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const { updates } = body;
+        if (!updates || !Array.isArray(updates) || updates.length === 0) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'updates array is required' }));
+            return;
+        }
+        const workspaceId = requestWorkspaceId(req);
+        const preview = core.bulkUpdateFieldsPreview(updates, workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: true,
+            summary: {
+                operation: 'bulk-update-fields-preview',
+                total: preview.total,
+                deduped: preview.deduped,
+                to_apply: preview.toApply.length,
+                skipped: preview.skipped.length
+            },
+            results: {
+                by_field: preview.byField,
+                priority_before: preview.priorityBefore,
+                priority_after: preview.priorityAfter,
+                to_apply: preview.toApply.map((item) => ({
+                    index: item.index,
+                    id: item.id,
+                    fields: item.changedFields
+                })),
+                skipped: preview.skipped
+            }
+        }));
+    });
+    // === SECTION: Initiative templates ===
+    // GET /api/taskforce/initiative-templates - List built-in initiative templates
+    addRoute('GET', '/api/taskforce/initiative-templates', async (req, res) => {
+        const templates = core.getInitiativeTemplates();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ templates }));
+    });
+    // POST /api/taskforce/initiative-templates/create - Create initiative + milestones from template
+    addRoute('POST', '/api/taskforce/initiative-templates/create', async (req, res) => {
+        const body = await parseJsonBody(req);
+        const { templateId, title } = body || {};
+        if (!templateId || !title) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'templateId and title are required' }));
+            return;
+        }
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const result = core.createInitiativeFromTemplate(body, workspaceId);
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: true,
+                summary: {
+                    operation: 'initiative-template-create',
+                    total: 1 + result.milestones.length,
+                    succeeded: 1 + result.milestones.length,
+                    failed: 0,
+                    partial: false
+                },
+                results: result,
+                errors: []
+            }));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to create initiative from template';
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: message,
+                code: error instanceof TaskforceRuleError ? error.code : error?.code,
+                details: error instanceof TaskforceRuleError ? error.details : error?.details
+            }));
+        }
+    });
+    // === SECTION: Taxonomy management ===
+    // GET /api/taskforce/taxonomy-library - List built-in taxonomy library packs
+    addRoute('GET', '/api/taskforce/taxonomy-library', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const packs = listBuiltInTaxonomyLibraryPacks();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ packs }));
+    });
+    // GET /api/taskforce/custom-taxonomy-library - List built-in custom taxonomy library packs
+    addRoute('GET', '/api/taskforce/custom-taxonomy-library', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const packs = listBuiltInCustomTaxonomyLibraryPacks();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ packs }));
+    });
+    // GET /api/taskforce/taxonomy-state - Get unified workspace taxonomy state
+    addRoute('GET', '/api/taskforce/taxonomy-state', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const taxonomyState = core.getTaxonomyState(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(taxonomyState));
+    });
+    addRoute('POST', '/api/taskforce/taxonomy-display-labels', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const body = await parseJsonBody(req);
+        const displayLabels = core.updateTaxonomyDisplayLabels(body?.displayLabels || {}, workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, displayLabels }));
+    });
+    // GET /api/taskforce/categories - Get project categories
+    addRoute('GET', '/api/taskforce/categories', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const categories = core.getCategories(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ categories }));
+    });
+    // POST /api/taskforce/categories - Update project categories
+    addRoute('POST', '/api/taskforce/categories', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const body = await parseJsonBody(req);
+        const { categories } = body;
+        if (!categories || !Array.isArray(categories)) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'categories array is required' }));
+            return;
+        }
+        core.updateCategories(categories, workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, categories: core.getCategories(workspaceId) }));
+    });
+    // GET /api/taskforce/types - Get project task types
+    addRoute('GET', '/api/taskforce/types', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const types = core.getTypes(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ types }));
+    });
+    // POST /api/taskforce/types - Update project task types
+    addRoute('POST', '/api/taskforce/types', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const body = await parseJsonBody(req);
+        const { types } = body;
+        if (!types || !Array.isArray(types)) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'types array is required' }));
+            return;
+        }
+        core.updateTypes(types, workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, types: core.getTypes(workspaceId) }));
+    });
+    // GET /api/taskforce/priorities - Get project priority levels
+    addRoute('GET', '/api/taskforce/priorities', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const priorities = core.getPriorities(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ priorities }));
+    });
+    // POST /api/taskforce/priorities - Update project priority levels
+    addRoute('POST', '/api/taskforce/priorities', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const body = await parseJsonBody(req);
+        const { priorities } = body;
+        if (!priorities || !Array.isArray(priorities)) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'priorities array is required' }));
+            return;
+        }
+        core.updatePriorities(priorities, workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, priorities: core.getPriorities(workspaceId) }));
+    });
+    // GET /api/taskforce/approaches - Get project approach options
+    addRoute('GET', '/api/taskforce/approaches', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const approaches = core.getApproaches();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ approaches }));
+    });
+    // POST /api/taskforce/approaches - Update project approach options
+    addRoute('POST', '/api/taskforce/approaches', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        const { approaches } = body;
+        if (!approaches || !Array.isArray(approaches)) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'approaches array is required' }));
+            return;
+        }
+        core.updateApproaches(approaches);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, approaches: core.getApproaches() }));
+    });
+    // GET /api/taskforce/taxonomies - Get project taxonomies
+    addRoute('GET', '/api/taskforce/taxonomies', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const taxonomies = core.getTaxonomies(workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ taxonomies }));
+    });
+    // POST /api/taskforce/taxonomies - Update project taxonomies
+    addRoute('POST', '/api/taskforce/taxonomies', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const body = await parseJsonBody(req);
+        const { taxonomies } = body;
+        if (!taxonomies || !Array.isArray(taxonomies)) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'taxonomies array is required' }));
+            return;
+        }
+        core.updateTaxonomies(taxonomies, workspaceId);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, taxonomies: core.getTaxonomies(workspaceId) }));
+    });
+}