@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/server/routes/tasks.js

@@ -44,24 +44,90 @@
  *   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 { createHash, randomUUID } from 'crypto';
 import { TaskforceRuleError } from '../../core/Taskforce.js';
+import { parseTaskRestoreDestination } from '../../shared/taskRestoreDestination.js';
+import { buildUserGlobalSettingsUpdate } from '../../core/GlobalSettingsService.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 './primitives.js';
 import { resolveRequestAccess } from '../auth.js';
-import { getRouteTimingNow, logSlowBootstrapRoute, requestBootstrapTraceId, requestHeader, requestRuntimeMode, resolveErrorStatusCode, serializeJsonWithTiming, setServerTimingHeader } from './shared.js';
+import { getRouteTimingNow, logSlowBootstrapRoute, requestBootstrapTraceId, requestHeader, requestRuntimeMode, requestUserId, resolveErrorStatusCode, serializeJsonWithTiming, setServerTimingHeader } from './shared.js';
 import { listBuiltInCustomTaxonomyLibraryPacks } from '../../shared/customTaxonomyLibrary.js';
-import { listBuiltInTaxonomyLibraryPacks } from '../../shared/taxonomyLibrary.js';
+import { getBuiltInTaxonomyLibraryPack, listBuiltInTaxonomyLibraryPacks } from '../../shared/taxonomyLibrary.js';
 import { shouldUseProvisionalTaskReferences } from '../../utils/taskReferences.js';
+import { createDurableTaxonomyMutationRouter } from '../../sync/v3/durableTaxonomyMutationRouter.js';
+import { buildCanonicalTaxonomyStateMutation, } from '../../sync/v3/taxonomyStateMutation.js';
+import { serializeTaxonomyStateForSync } from '../../sync/v3/taxonomySyncPayload.js';
+import { createDurableInitiativeMutationRouter } from '../../sync/v3/durableInitiativeMutationRouter.js';
+import { createDurableWorkstreamMutationRouter } from '../../sync/v3/durableWorkstreamMutationRouter.js';
+import { createDurableWorkstreamTaskOrderMutationRouter } from '../../sync/v3/durableWorkstreamTaskOrderMutationRouter.js';
+import { serializeCanonicalPlanningAttachmentLinks } from '../../sync/planningCanonicalFields.js';
+import { createTaskHttpDurableRouters } from './durableTaskHttpRouters.js';
 // === SECTION: Module dependency interface ===
 const UI_STATE_MAX_JSON_BODY_BYTES = 50 * 1024 * 1024;
+function normalizeDurableChecklistItems(input) {
+    const existingById = new Map((input.task.checklistItems || []).map((item) => [item.id, item]));
+    return input.items.map((raw, index) => {
+        const item = raw && typeof raw === 'object' ? raw : {};
+        const id = String(item.id || `checklist-${createHash('sha256').update(`${input.operationId}:${input.taskId}:${index}`).digest('hex').slice(0, 32)}`);
+        const existing = existingById.get(id);
+        const title = String(item.title || '').trim();
+        const isCompleted = item.isCompleted === true;
+        const order = Number.isFinite(Number(item.order)) ? Number(item.order) : index;
+        const unchanged = existing && existing.title === title
+            && existing.isCompleted === isCompleted && existing.order === order;
+        const createdAt = String(existing?.createdAt || item.createdAt || input.now);
+        return {
+            id,
+            taskId: input.taskId,
+            title,
+            isCompleted,
+            order,
+            createdAt,
+            updatedAt: String(unchanged ? existing.updatedAt : existing ? input.now : item.updatedAt || createdAt),
+        };
+    });
+}
+function normalizeDurableTaskAttachmentLinks(input) {
+    return input.attachments.map((raw, order) => {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+            throw new TaskforceRuleError('Each durable task attachment must include canonical asset metadata.', 400, 'TASK_ATTACHMENT_LINKS_INVALID');
+        }
+        const source = raw;
+        const assetId = String(source.assetId || '').trim();
+        if (!assetId) {
+            throw new TaskforceRuleError('Each durable task attachment must include assetId.', 400, 'TASK_ATTACHMENT_LINKS_INVALID');
+        }
+        const asset = input.core.getWorkspaceAssetStore().get(assetId, input.workspaceId);
+        const requestedRole = String(source.linkRole || '').trim();
+        const role = requestedRole === 'reference'
+            || requestedRole === 'image' || requestedRole === 'attachment'
+            ? requestedRole
+            : asset?.storageProvider === 'external'
+                ? 'reference'
+                : asset?.kind === 'image' ? 'image' : 'attachment';
+        return {
+            assetId,
+            role,
+            order,
+            ...(typeof source.caption === 'string' ? { caption: source.caption } : {}),
+            ...(typeof source.displayName === 'string' ? { displayName: source.displayName } : {}),
+            ...(typeof source.originalFilename === 'string' ? { originalFilename: source.originalFilename } : {}),
+            ...(source.referenceNumber === null || Number.isSafeInteger(source.referenceNumber)
+                ? { referenceNumber: source.referenceNumber }
+                : {}),
+            ...(source.referenceLabel === null || typeof source.referenceLabel === 'string'
+                ? { referenceLabel: source.referenceLabel }
+                : {}),
+        };
+    });
+}
 function createUiStateRequestId() {
     return `ui-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -69,9 +135,102 @@ function attachUiStateDebugHeaders(res, requestId) {
     res.setHeader('x-taskforce-ui-state-route', 'tasks');
     res.setHeader('x-taskforce-ui-state-request-id', requestId);
 }
+function collectTopLevelKeys(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return [];
+    return Object.keys(value).sort();
+}
 // === SECTION: Registration ===
 export function registerTaskRoutes(deps) {
     const { addRoute, core, context, requestWorkspaceId, ensureAppAccess, resolveEffectiveObjectStorageConfig, buildBatchSummary, CLOUD_SAFE_CONFIG_PATHS, } = deps;
+    const mutateTaxonomyThroughDurableBoundary = (req, workspaceId, mutation, options) => {
+        const runtimeMode = context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req);
+        const router = createDurableTaxonomyMutationRouter({
+            core,
+            runtimeMode,
+            surface: 'http',
+            tenantId: core.getTenantId(),
+            workspaceId,
+        });
+        if (!router.enabled)
+            return null;
+        return router.mutateState(() => buildCanonicalTaxonomyStateMutation({
+            current: core.getTaxonomyState(workspaceId),
+            mutation,
+        }), options);
+    };
+    const writeTaxonomyMutationError = (res, error) => {
+        const statusCode = resolveErrorStatusCode(error, 400);
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: false,
+            error: error instanceof Error ? error.message : 'Taxonomy update failed.',
+            ...(error?.code ? { code: String(error.code) } : {}),
+        }));
+    };
+    const createInitiativeRouter = (req, workspaceId) => {
+        const runtimeMode = context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req);
+        const operationId = requestHeader(req, 'x-taskforce-operation-id', '').trim();
+        return createDurableInitiativeMutationRouter({
+            core,
+            runtimeMode,
+            surface: 'http',
+            tenantId: core.getTenantId(),
+            workspaceId,
+            actorRef: runtimeMode === 'cloud' ? (String(requestUserId(req) || '').trim() || 'user') : 'user',
+            cloudClientId: 'http-cloud',
+            ...(operationId ? { createOperationId: () => operationId } : {}),
+        });
+    };
+    const initiativeResult = (result) => (result.state === 'pending' ? result.provisionalInitiative : result.authoritativeInitiative);
+    const createWorkstreamRouter = (req, workspaceId) => {
+        const runtimeMode = context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req);
+        const operationId = requestHeader(req, 'x-taskforce-operation-id', '').trim();
+        return createDurableWorkstreamMutationRouter({
+            core,
+            runtimeMode,
+            surface: 'http',
+            tenantId: core.getTenantId(),
+            workspaceId,
+            actorRef: runtimeMode === 'cloud' ? (String(requestUserId(req) || '').trim() || 'user') : 'user',
+            cloudClientId: 'http-cloud',
+            ...(operationId ? { createOperationId: () => operationId } : {}),
+        });
+    };
+    const workstreamResult = (result) => (result.state === 'pending' ? result.provisionalWorkstream : result.authoritativeWorkstream);
+    const createTaskHttpRootRouter = (req, workspaceId, operationIdOverride, deferPostCommitNotification) => {
+        const routers = createTaskHttpDurableRouters({ core, context, req, workspaceId });
+        return operationIdOverride === undefined && !deferPostCommitNotification
+            ? routers.root
+            : routers.createRootRouter(operationIdOverride, deferPostCommitNotification);
+    };
+    const createTaskHttpBulkRouter = (req, workspaceId) => (createTaskHttpDurableRouters({ core, context, req, workspaceId }).bulk);
+    const writeInitiativeMutationError = (res, error, fallback) => {
+        const statusCode = resolveErrorStatusCode(error, 400);
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            error: error instanceof Error ? error.message : fallback,
+            ...(error?.code ? { code: String(error.code) } : {}),
+        }));
+    };
+    const writeWorkstreamMutationError = (res, error, fallback) => {
+        const statusCode = resolveErrorStatusCode(error, 400);
+        const retryAt = typeof error?.retryAt === 'string'
+            ? String(error.retryAt)
+            : null;
+        const retryAfterSeconds = retryAt && Number.isFinite(Date.parse(retryAt))
+            ? Math.max(0, Math.ceil((Date.parse(retryAt) - Date.now()) / 1_000))
+            : null;
+        res.writeHead(statusCode, {
+            'Content-Type': 'application/json',
+            ...(retryAfterSeconds !== null ? { 'Retry-After': String(retryAfterSeconds) } : {}),
+        });
+        res.end(JSON.stringify({
+            error: error instanceof Error ? error.message : fallback,
+            ...(error?.code ? { code: String(error.code) } : {}),
+            ...(retryAt ? { retryAt } : {}),
+        }));
+    };
     // === SECTION: Config and settings ===
     // GET /api/taskforce/config - Get current configuration
     addRoute('GET', '/api/taskforce/config', async (req, res) => {
@@ -136,10 +295,17 @@ export function registerTaskRoutes(deps) {
         if (!ensureAppAccess(req, res))
             return;
         const body = await parseJsonBody(req);
+        const applied = buildUserGlobalSettingsUpdate(body);
+        const requestedKeys = collectTopLevelKeys(body);
+        const appliedKeys = collectTopLevelKeys(applied);
+        const droppedKeys = requestedKeys.filter((key) => !appliedKeys.includes(key));
+        if (droppedKeys.length > 0) {
+            console.warn('[Taskforce Settings] Dropped unsupported global settings keys', { droppedKeys });
+        }
         try {
-            core.updateGlobalSettings(body);
+            core.updateGlobalSettings(applied);
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true }));
+            res.end(JSON.stringify({ success: true, applied, droppedKeys }));
         }
         catch {
             res.writeHead(500, { 'Content-Type': 'application/json' });
@@ -157,6 +323,7 @@ export function registerTaskRoutes(deps) {
         const runtimeHeader = String((req.headers['x-taskforce-runtime-mode'] || '')).toLowerCase();
         const isLocalRuntime = runtimeHeader === 'local';
         const allowCreate = body?.allowCreate === true;
+        const createIfMissing = isLocalRuntime && body?.createIfMissing === true;
         const explicitWorkspaceId = typeof body?.workspaceId === 'string'
             ? body.workspaceId.trim()
             : '';
@@ -164,14 +331,16 @@ export function registerTaskRoutes(deps) {
         const incomingWorkspaceId = String(explicitWorkspaceId
             || ((isLocalRuntime && allowCreate && !explicitWorkspaceId) ? '' : headerWorkspaceId)).trim() || 'default';
         try {
-            const workspaceExists = Boolean(core.getWorkspaceProfile(incomingWorkspaceId));
+            const existingWorkspace = core.getWorkspaceProfile(incomingWorkspaceId);
+            const workspaceExists = Boolean(existingWorkspace);
             const authConfig = context.authConfig;
             const requestAccess = authConfig?.enabled
                 ? resolveRequestAccess(req, authConfig)
                 : null;
             const shouldCreateWorkspace = Boolean(name
                 && (incomingWorkspaceId === 'default' || !workspaceExists)
-                && (isLocalRuntime || allowCreate));
+                && (isLocalRuntime || allowCreate)
+                && (!createIfMissing || !workspaceExists));
             const workspace = shouldCreateWorkspace
                 ? (!isLocalRuntime
                     && requestAccess?.authenticated
@@ -190,7 +359,9 @@ export function registerTaskRoutes(deps) {
                         description,
                         slug
                     }))
-                : core.updateWorkspaceProfile(incomingWorkspaceId, { name, description, slug });
+                : (createIfMissing && existingWorkspace
+                    ? existingWorkspace
+                    : core.updateWorkspaceProfile(incomingWorkspaceId, { name, description, slug }));
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ success: true, workspace }));
         }
@@ -254,9 +425,9 @@ export function registerTaskRoutes(deps) {
                 : body?.state && typeof body.state === 'object'
                     ? body.state
                     : {};
-            core.updateUiState(workspaceId, userId, { stateKey, patch });
+            const state = core.updateUiState(workspaceId, userId, { stateKey, patch });
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true }));
+            res.end(JSON.stringify({ success: true, state }));
         }
         catch (error) {
             const statusCode = resolveErrorStatusCode(error, 400);
@@ -298,6 +469,13 @@ export function registerTaskRoutes(deps) {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(data));
     });
+    addRoute('GET', '/api/taskforce/task-relationships', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ relationships: core.listTaskRelationshipsForSync(workspaceId) }));
+    });
     const handleListDeletedTasks = async (req, res) => {
         if (!ensureAppAccess(req, res))
             return;
@@ -408,7 +586,8 @@ export function registerTaskRoutes(deps) {
         }
         try {
             const workspaceId = requestWorkspaceId(req);
-            const task = core.createTask(taskInput, {
+            const durableRouter = createTaskHttpRootRouter(req, workspaceId);
+            const task = durableRouter.enabled ? durableRouter.create(taskInput) : core.createTask(taskInput, {
                 workspaceId,
                 actorRef: 'user',
                 provisionalLocalReference: shouldUseProvisionalTaskReferences(requestRuntimeMode(req))
@@ -441,10 +620,68 @@ export function registerTaskRoutes(deps) {
             const updates = body && typeof body === 'object'
                 ? Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'saveSource'))
                 : body;
-            const updated = core.updateTask(params.id, updates, workspaceId, {
-                actorRef: 'user',
-                saveSource
-            });
+            const durableRouters = createTaskHttpDurableRouters({ core, context, req, workspaceId });
+            const durableRouter = durableRouters.root;
+            const hasChecklist = Object.prototype.hasOwnProperty.call(updates || {}, 'checklistItems');
+            if (hasChecklist && !Array.isArray(updates.checklistItems)) {
+                throw new TaskforceRuleError('checklistItems must be an array.', 400, 'TASK_CHECKLIST_INVALID');
+            }
+            const hasAttachments = Object.prototype.hasOwnProperty.call(updates || {}, 'attachments');
+            if (hasAttachments && !Array.isArray(updates.attachments)) {
+                throw new TaskforceRuleError('attachments must be an array.', 400, 'TASK_ATTACHMENT_LINKS_INVALID');
+            }
+            const checklistDurable = hasChecklist && durableRouters.checklist.enabled;
+            const attachmentLinksDurable = hasAttachments && durableRouters.attachmentLinks.enabled;
+            const rawChecklistItems = hasChecklist ? updates.checklistItems : [];
+            const rawAttachments = hasAttachments ? updates.attachments : [];
+            const remainingUpdates = checklistDurable || attachmentLinksDurable
+                ? Object.fromEntries(Object.entries(updates).filter(([key]) => (!(checklistDurable && key === 'checklistItems')
+                    && !(attachmentLinksDurable && key === 'attachments'))))
+                : updates;
+            let updated;
+            const durableTargetCount = Number(checklistDurable)
+                + Number(attachmentLinksDurable)
+                + Number(Object.keys(remainingUpdates).length > 0);
+            if (durableTargetCount > 1) {
+                const aggregate = durableRouters.bulk.updateFields([
+                    { id: params.id, ...updates },
+                ], { saveSource, atomicItemFailures: true });
+                const failure = aggregate.errors[0];
+                if (failure) {
+                    throw new TaskforceRuleError(failure.message, failure.statusCode, failure.code || 'TASK_UPDATE_FAILED', failure.details);
+                }
+                updated = core.getTask(params.id, workspaceId) || aggregate.results[0];
+            }
+            else {
+                updated = Object.keys(remainingUpdates || {}).length > 0
+                    ? (durableRouter.enabled
+                        ? durableRouter.update(params.id, remainingUpdates, saveSource)
+                        : core.updateTask(params.id, remainingUpdates, workspaceId, {
+                            actorRef: 'user',
+                            saveSource,
+                        }))
+                    : core.getTask(params.id, workspaceId);
+                if (updated && checklistDurable) {
+                    const checklistRouter = durableRouters.createChecklistRouter(durableRouters.deriveChildOperationId('task-patch-checklist', 0, params.id));
+                    const checklistItems = normalizeDurableChecklistItems({
+                        items: rawChecklistItems,
+                        task: core.getTask(params.id, workspaceId) || updated,
+                        taskId: params.id,
+                        operationId: requestHeader(req, 'x-taskforce-operation-id', '').trim(),
+                        now: new Date().toISOString(),
+                    });
+                    updated = checklistRouter.replace({ taskId: params.id, items: checklistItems }).task;
+                }
+                if (updated && attachmentLinksDurable) {
+                    const attachmentLinksRouter = durableRouters.createAttachmentLinksRouter(durableRouters.deriveChildOperationId('task-patch-attachments', 0, params.id));
+                    const links = normalizeDurableTaskAttachmentLinks({
+                        attachments: rawAttachments,
+                        core,
+                        workspaceId,
+                    });
+                    updated = attachmentLinksRouter.replace({ taskId: params.id, links }).task;
+                }
+            }
             if (!updated) {
                 res.writeHead(404, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ error: 'Task not found' }));
@@ -456,8 +693,10 @@ export function registerTaskRoutes(deps) {
         catch (error) {
             const statusCode = resolveErrorStatusCode(error, 400);
             const message = error instanceof Error ? error.message : 'Failed to update 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 }));
+            res.end(JSON.stringify({ error: message, code: errorCode, details: errorDetails }));
         }
     });
     // GET /api/taskforce/task/:id/checklist - Read structured checklist items for one task
@@ -480,8 +719,11 @@ export function registerTaskRoutes(deps) {
         if (!ensureAppAccess(req, res))
             return;
         const body = await parseJsonBody(req);
-        const items = Array.isArray(body?.items) ? body.items : [];
         try {
+            if (!Array.isArray(body?.items)) {
+                throw new TaskforceRuleError('Checklist items must be an array.', 400, 'TASK_CHECKLIST_INVALID');
+            }
+            const items = body.items;
             const workspaceId = requestWorkspaceId(req);
             const task = core.getTask(params.id, workspaceId);
             if (!task) {
@@ -489,15 +731,26 @@ export function registerTaskRoutes(deps) {
                 res.end(JSON.stringify({ error: 'Task not found' }));
                 return;
             }
-            const updated = core.replaceChecklistItems(params.id, items, workspaceId);
+            const durableRouter = createTaskHttpDurableRouters({ core, context, req, workspaceId }).checklist;
+            const durableItems = durableRouter.enabled ? normalizeDurableChecklistItems({
+                items,
+                task,
+                taskId: params.id,
+                operationId: requestHeader(req, 'x-taskforce-operation-id', '').trim(),
+                now: new Date().toISOString(),
+            }) : items;
+            const updated = durableRouter.enabled
+                ? durableRouter.replace({ taskId: params.id, items: durableItems }).task.checklistItems || []
+                : 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';
+            const errorCode = error instanceof TaskforceRuleError ? error.code : error?.code;
             res.writeHead(statusCode, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: message }));
+            res.end(JSON.stringify({ error: message, code: errorCode }));
         }
     });
     // GET /api/taskforce/initiatives - List initiatives
@@ -558,15 +811,38 @@ export function registerTaskRoutes(deps) {
         const body = await parseJsonBody(req);
         try {
             const workspaceId = requestWorkspaceId(req);
-            const initiative = core.createInitiative(body || {}, workspaceId, { actorRef: 'user' });
+            const router = createInitiativeRouter(req, workspaceId);
+            const allowed = new Set(['id', 'title', 'description', 'ownerId', 'order', 'attachments', 'createdAt']);
+            const unsupported = Object.keys(body || {}).filter((key) => !allowed.has(key));
+            if (router.enabled && unsupported.length > 0) {
+                const error = new Error(`Unsupported initiative fields: ${unsupported.sort().join(', ')}`);
+                error.code = 'INITIATIVE_MUTATION_INVALID';
+                error.statusCode = 400;
+                throw error;
+            }
+            if (router.enabled && (!String(body?.id || '').trim() || !String(body?.createdAt || '').trim())) {
+                const error = new Error('Activated initiative create requires stable id and createdAt fields.');
+                error.code = 'INITIATIVE_MUTATION_IDENTITY_REQUIRED';
+                error.statusCode = 400;
+                throw error;
+            }
+            const initiative = router.enabled
+                ? initiativeResult(router.create(String(body?.id || '').trim() || `initiative-${randomUUID()}`, {
+                    title: body?.title,
+                    description: body?.description ?? null,
+                    ownerId: body?.ownerId ?? null,
+                    order: body?.order ?? null,
+                    attachments: serializeCanonicalPlanningAttachmentLinks(body?.attachments ?? []),
+                    createdAt: String(body?.createdAt || '').trim() || new Date().toISOString(),
+                }))
+                : core.createInitiative(body || {}, workspaceId, { actorRef: 'user' });
+            if (!initiative)
+                throw new Error('Durable initiative capture did not return a provisional initiative.');
             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 }));
+            writeInitiativeMutationError(res, error, 'Failed to create initiative');
         }
     });
     // GET /api/taskforce/initiative/:id - Read one initiative
@@ -590,15 +866,31 @@ export function registerTaskRoutes(deps) {
         const body = await parseJsonBody(req);
         try {
             const workspaceId = requestWorkspaceId(req);
-            const updated = core.updateInitiative(params.id, body || {}, workspaceId, { actorRef: 'user' });
+            const router = createInitiativeRouter(req, workspaceId);
+            const allowed = new Set(['title', 'description', 'ownerId', 'order', 'attachments']);
+            const unsupported = Object.keys(body || {}).filter((key) => !allowed.has(key));
+            if (router.enabled && unsupported.length > 0) {
+                const error = new Error(`Unsupported initiative fields: ${unsupported.sort().join(', ')}`);
+                error.code = 'INITIATIVE_MUTATION_INVALID';
+                error.statusCode = 400;
+                throw error;
+            }
+            const durablePatch = {
+                ...(body || {}),
+                ...(body && Object.prototype.hasOwnProperty.call(body, 'attachments')
+                    ? { attachments: serializeCanonicalPlanningAttachmentLinks(body.attachments) }
+                    : {}),
+            };
+            const updated = router.enabled
+                ? initiativeResult(router.updateMetadata(params.id, durablePatch))
+                : core.updateInitiative(params.id, body || {}, workspaceId, { actorRef: 'user' });
+            if (!updated)
+                throw new Error('Durable initiative capture did not return a provisional initiative.');
             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 }));
+            writeInitiativeMutationError(res, error, 'Failed to update initiative');
         }
     });
     addRoute('POST', '/api/taskforce/initiative/:id/archive', async (req, res, params) => {
@@ -606,15 +898,17 @@ export function registerTaskRoutes(deps) {
             return;
         try {
             const workspaceId = requestWorkspaceId(req);
-            const archived = core.archiveInitiative(params.id, workspaceId, { actorRef: 'user' });
+            const router = createInitiativeRouter(req, workspaceId);
+            const archived = router.enabled
+                ? initiativeResult(router.archive(params.id))
+                : core.archiveInitiative(params.id, workspaceId, { actorRef: 'user' });
+            if (!archived)
+                throw new Error('Durable initiative capture did not return a provisional initiative.');
             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 }));
+            writeInitiativeMutationError(res, error, 'Failed to archive initiative');
         }
     });
     addRoute('POST', '/api/taskforce/initiative/:id/unarchive', async (req, res, params) => {
@@ -622,15 +916,17 @@ export function registerTaskRoutes(deps) {
             return;
         try {
             const workspaceId = requestWorkspaceId(req);
-            const restored = core.unarchiveInitiative(params.id, workspaceId, { actorRef: 'user' });
+            const router = createInitiativeRouter(req, workspaceId);
+            const restored = router.enabled
+                ? initiativeResult(router.unarchive(params.id))
+                : core.unarchiveInitiative(params.id, workspaceId, { actorRef: 'user' });
+            if (!restored)
+                throw new Error('Durable initiative capture did not return a provisional initiative.');
             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 }));
+            writeInitiativeMutationError(res, error, 'Failed to unarchive initiative');
         }
     });
     // GET /api/taskforce/workstreams - List workstreams
@@ -649,15 +945,39 @@ export function registerTaskRoutes(deps) {
         const body = await parseJsonBody(req);
         try {
             const workspaceId = requestWorkspaceId(req);
-            const workstream = core.createWorkstream(body || {}, workspaceId, { actorRef: 'user' });
+            const router = createWorkstreamRouter(req, workspaceId);
+            const allowed = new Set(['id', 'initiativeId', 'title', 'description', 'ownerId', 'order', 'attachments', 'createdAt']);
+            const unsupported = Object.keys(body || {}).filter((key) => !allowed.has(key));
+            if (router.enabled && unsupported.length > 0) {
+                const error = new Error(`Unsupported workstream fields: ${unsupported.sort().join(', ')}`);
+                error.code = 'WORKSTREAM_MUTATION_INVALID';
+                error.statusCode = 400;
+                throw error;
+            }
+            if (router.enabled && (!String(body?.id || '').trim() || !String(body?.createdAt || '').trim())) {
+                const error = new Error('Activated workstream create requires stable id and createdAt fields.');
+                error.code = 'WORKSTREAM_MUTATION_IDENTITY_REQUIRED';
+                error.statusCode = 400;
+                throw error;
+            }
+            const workstream = router.enabled
+                ? workstreamResult(router.create(String(body?.id || '').trim(), {
+                    initiativeId: body?.initiativeId ?? null,
+                    title: body?.title,
+                    description: body?.description ?? null,
+                    ownerId: body?.ownerId ?? null,
+                    order: body?.order ?? null,
+                    attachments: serializeCanonicalPlanningAttachmentLinks(body?.attachments ?? []),
+                    createdAt: String(body?.createdAt || '').trim(),
+                }))
+                : core.createWorkstream(body || {}, workspaceId, { actorRef: 'user' });
+            if (!workstream)
+                throw new Error('Durable workstream capture did not return a provisional workstream.');
             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 }));
+            writeWorkstreamMutationError(res, error, 'Failed to create workstream');
         }
     });
     // GET /api/taskforce/workstream/:id - Read one workstream
@@ -681,15 +1001,31 @@ export function registerTaskRoutes(deps) {
         const body = await parseJsonBody(req);
         try {
             const workspaceId = requestWorkspaceId(req);
-            const updated = core.updateWorkstream(params.id, body || {}, workspaceId, { actorRef: 'user' });
+            const router = createWorkstreamRouter(req, workspaceId);
+            const allowed = new Set(['initiativeId', 'title', 'description', 'ownerId', 'order', 'attachments']);
+            const unsupported = Object.keys(body || {}).filter((key) => !allowed.has(key));
+            if (router.enabled && unsupported.length > 0) {
+                const error = new Error(`Unsupported workstream fields: ${unsupported.sort().join(', ')}`);
+                error.code = 'WORKSTREAM_MUTATION_INVALID';
+                error.statusCode = 400;
+                throw error;
+            }
+            const durablePatch = {
+                ...(body || {}),
+                ...(body && Object.prototype.hasOwnProperty.call(body, 'attachments')
+                    ? { attachments: serializeCanonicalPlanningAttachmentLinks(body.attachments) }
+                    : {}),
+            };
+            const updated = router.enabled
+                ? workstreamResult(router.updateMetadata(params.id, durablePatch))
+                : core.updateWorkstream(params.id, body || {}, workspaceId, { actorRef: 'user' });
+            if (!updated)
+                throw new Error('Durable workstream capture did not return a provisional workstream.');
             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 }));
+            writeWorkstreamMutationError(res, error, 'Failed to update workstream');
         }
     });
     addRoute('POST', '/api/taskforce/workstream/:id/archive', async (req, res, params) => {
@@ -697,15 +1033,17 @@ export function registerTaskRoutes(deps) {
             return;
         try {
             const workspaceId = requestWorkspaceId(req);
-            const archived = core.archiveWorkstream(params.id, workspaceId, { actorRef: 'user' });
+            const router = createWorkstreamRouter(req, workspaceId);
+            const archived = router.enabled
+                ? workstreamResult(router.archive(params.id))
+                : core.archiveWorkstream(params.id, workspaceId, { actorRef: 'user' });
+            if (!archived)
+                throw new Error('Durable workstream capture did not return a provisional workstream.');
             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 }));
+            writeWorkstreamMutationError(res, error, 'Failed to archive workstream');
         }
     });
     addRoute('POST', '/api/taskforce/workstream/:id/unarchive', async (req, res, params) => {
@@ -713,15 +1051,56 @@ export function registerTaskRoutes(deps) {
             return;
         try {
             const workspaceId = requestWorkspaceId(req);
-            const restored = core.unarchiveWorkstream(params.id, workspaceId, { actorRef: 'user' });
+            const router = createWorkstreamRouter(req, workspaceId);
+            const restored = router.enabled
+                ? workstreamResult(router.unarchive(params.id))
+                : core.unarchiveWorkstream(params.id, workspaceId, { actorRef: 'user' });
+            if (!restored)
+                throw new Error('Durable workstream capture did not return a provisional workstream.');
             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 }));
+            writeWorkstreamMutationError(res, error, 'Failed to unarchive workstream');
+        }
+    });
+    addRoute('POST', '/api/taskforce/workstream/:id/task-order', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            if (!Array.isArray(body?.taskIds)) {
+                const error = new Error('taskIds must be an array.');
+                error.code = 'WORKSTREAM_TASK_ORDER_INVALID';
+                error.statusCode = 400;
+                throw error;
+            }
+            const runtimeMode = context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req);
+            const operationId = requestHeader(req, 'x-taskforce-operation-id', '').trim();
+            const router = createDurableWorkstreamTaskOrderMutationRouter({
+                core,
+                runtimeMode,
+                tenantId: core.getTenantId(),
+                workspaceId,
+                cloudClientId: 'http-cloud',
+                ...(operationId ? { operationId } : {}),
+            });
+            const taskIds = body.taskIds.map((value) => String(value || '').trim());
+            let orderedTaskIds;
+            if (router.enabled) {
+                orderedTaskIds = router.replace(params.id, taskIds).taskIds;
+            }
+            else {
+                orderedTaskIds = core.replaceWorkstreamTaskOrder(params.id, taskIds, workspaceId)
+                    .map((task) => task.id);
+                core.notifyDurableTaskBatchCommitted(workspaceId, orderedTaskIds);
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, workstreamId: params.id, taskIds: orderedTaskIds }));
+        }
+        catch (error) {
+            writeWorkstreamMutationError(res, error, 'Failed to reorder workstream tasks');
         }
     });
     // PATCH /api/taskforce/task/:id/schedule - Update schedule fields for one task
@@ -731,10 +1110,19 @@ export function registerTaskRoutes(deps) {
         const body = await parseJsonBody(req);
         try {
             const workspaceId = requestWorkspaceId(req);
-            const result = core.updateTaskSchedule(params.id, {
-                scheduledDate: body?.scheduledDate ?? null,
-                orderInDay: body?.orderInDay
-            }, workspaceId);
+            const durableRouter = createTaskHttpRootRouter(req, workspaceId);
+            const result = durableRouter.enabled
+                ? (() => {
+                    const task = durableRouter.update(params.id, {
+                        scheduledDate: body?.scheduledDate ?? null,
+                        orderInDay: body?.orderInDay,
+                    }, 'manual', 'task-schedule-changed');
+                    return { task, warnings: core.getTaskSchedulingWarnings(task) };
+                })()
+                : 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' }));
@@ -760,7 +1148,21 @@ export function registerTaskRoutes(deps) {
         try {
             const moves = Array.isArray(body?.moves) ? body.moves : [];
             const workspaceId = requestWorkspaceId(req);
-            const result = core.reorderScheduledTasks(moves, workspaceId);
+            const durableRouters = createTaskHttpDurableRouters({ core, context, req, workspaceId });
+            const rootRouter = durableRouters.root;
+            const result = rootRouter.enabled
+                ? rootRouter.runBatch('schedule/reorder', { moves }, () => (moves.reduce((aggregate, move, index) => {
+                    const taskId = String(move?.id || '').trim();
+                    const router = durableRouters.createRootRouter(durableRouters.deriveChildOperationId('schedule/reorder', index, taskId));
+                    const task = router.update(taskId, {
+                        scheduledDate: move?.scheduledDate ?? null,
+                        orderInDay: move?.orderInDay,
+                    }, 'manual', 'task-schedule-changed');
+                    aggregate.tasks.push(task);
+                    aggregate.warnings.push(...core.getTaskSchedulingWarnings(task));
+                    return aggregate;
+                }, { tasks: [], warnings: [] })))
+                : core.reorderScheduledTasks(moves, workspaceId);
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify(result));
         }
@@ -788,7 +1190,10 @@ export function registerTaskRoutes(deps) {
             return;
         try {
             const workspaceId = requestWorkspaceId(req);
-            const archived = core.archiveTask(params.id, false, undefined, workspaceId, { actorRef: 'user' });
+            const durableRouter = createTaskHttpRootRouter(req, workspaceId);
+            const archived = durableRouter.enabled
+                ? durableRouter.archive(params.id, false, null)
+                : 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' }));
@@ -800,8 +1205,9 @@ export function registerTaskRoutes(deps) {
         catch (error) {
             const statusCode = resolveErrorStatusCode(error, 400);
             const message = error instanceof Error ? error.message : 'Failed to archive task';
+            const errorCode = error?.code;
             res.writeHead(statusCode, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: message }));
+            res.end(JSON.stringify({ error: message, code: errorCode }));
         }
     });
     // POST /api/taskforce/task/:id/cancel - Archive as cancelled
@@ -812,7 +1218,10 @@ export function registerTaskRoutes(deps) {
         const reason = body.reason || 'Cancelled';
         try {
             const workspaceId = requestWorkspaceId(req);
-            const archived = core.archiveTask(params.id, true, reason, workspaceId, { actorRef: 'user' });
+            const durableRouter = createTaskHttpRootRouter(req, workspaceId);
+            const archived = durableRouter.enabled
+                ? durableRouter.archive(params.id, true, reason)
+                : 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' }));
@@ -824,8 +1233,9 @@ export function registerTaskRoutes(deps) {
         catch (error) {
             const statusCode = resolveErrorStatusCode(error, 400);
             const message = error instanceof Error ? error.message : 'Failed to cancel task';
+            const errorCode = error?.code;
             res.writeHead(statusCode, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: message }));
+            res.end(JSON.stringify({ error: message, code: errorCode }));
         }
     });
     // DELETE /api/taskforce/task/:id - Delete a task
@@ -834,7 +1244,10 @@ export function registerTaskRoutes(deps) {
             return;
         try {
             const workspaceId = requestWorkspaceId(req);
-            const deleted = core.softDeleteTask(params.id, workspaceId, { actorRef: 'user', source: 'ui' });
+            const durableRouter = createTaskHttpRootRouter(req, workspaceId);
+            const deleted = durableRouter.enabled
+                ? durableRouter.delete(params.id)
+                : 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' }));
@@ -846,8 +1259,9 @@ export function registerTaskRoutes(deps) {
         catch (error) {
             const statusCode = resolveErrorStatusCode(error, 400);
             const message = error instanceof Error ? error.message : 'Failed to delete task';
+            const errorCode = error?.code;
             res.writeHead(statusCode, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: message }));
+            res.end(JSON.stringify({ error: message, code: errorCode }));
         }
     });
     const handleRestoreDeletedTaskRoute = async (req, res, params) => {
@@ -855,7 +1269,10 @@ export function registerTaskRoutes(deps) {
             return;
         try {
             const workspaceId = requestWorkspaceId(req);
-            const restored = core.restoreDeletedTask(params.id, workspaceId, { actorRef: 'user' });
+            const durableRouter = createTaskHttpRootRouter(req, workspaceId);
+            const restored = durableRouter.enabled
+                ? durableRouter.restore(params.id)
+                : 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' }));
@@ -875,6 +1292,136 @@ export function registerTaskRoutes(deps) {
     // 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 handleRestoreDeletedTaskBatch = async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const body = await parseJsonBody(req);
+        if (!Array.isArray(body.ids) || body.ids.length === 0) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: 'ids must be a non-empty array of deleted record ids.',
+                code: 'DELETED_TASK_RESTORE_BATCH_INVALID',
+            }));
+            return;
+        }
+        if (body.ids.length > 100) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: 'A maximum of 100 deleted tasks can be restored per request.',
+                code: 'DELETED_TASK_RESTORE_BATCH_LIMIT',
+            }));
+            return;
+        }
+        if (body.ids.some((value) => typeof value !== 'string' || !value.trim())) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: 'ids must contain unique, non-empty deleted record ids.',
+                code: 'DELETED_TASK_RESTORE_BATCH_INVALID',
+            }));
+            return;
+        }
+        const ids = body.ids.map((value) => value.trim());
+        if (new Set(ids).size !== ids.length) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: 'ids must contain unique, non-empty deleted record ids.',
+                code: 'DELETED_TASK_RESTORE_BATCH_INVALID',
+            }));
+            return;
+        }
+        const restoreDestination = parseTaskRestoreDestination(body.restoreDestination);
+        if (!restoreDestination) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: 'restoreDestination must be previous or archive.',
+                code: 'DELETED_TASK_RESTORE_DESTINATION_INVALID',
+            }));
+            return;
+        }
+        const workspaceId = requestWorkspaceId(req);
+        const durableRouters = createTaskHttpDurableRouters({ core, context, req, workspaceId });
+        let result;
+        try {
+            result = durableRouters.root.enabled
+                ? createTaskHttpBulkRouter(req, workspaceId).restoreDeleted(ids, restoreDestination)
+                : (() => {
+                    const restored = [];
+                    const errors = [];
+                    for (let index = 0; index < ids.length; index += 1) {
+                        const deletedRecordId = ids[index];
+                        try {
+                            const deleted = core.getDeletedTask(deletedRecordId, workspaceId);
+                            if (!deleted || deleted.id !== deletedRecordId) {
+                                errors.push({
+                                    index,
+                                    id: deletedRecordId,
+                                    message: 'Deleted task not found.',
+                                    statusCode: 404,
+                                    code: 'DELETED_TASK_NOT_FOUND',
+                                });
+                                continue;
+                            }
+                            const task = core.restoreDeletedTask(deletedRecordId, workspaceId, {
+                                actorRef: 'user',
+                                restoreDestination,
+                            });
+                            if (!task) {
+                                errors.push({
+                                    index,
+                                    id: deletedRecordId,
+                                    message: 'Deleted task not found.',
+                                    statusCode: 404,
+                                    code: 'DELETED_TASK_NOT_FOUND',
+                                });
+                                continue;
+                            }
+                            restored.push({
+                                deletedRecordId,
+                                taskId: task.id,
+                                task,
+                                restoredTo: task.isArchived === true ? 'archived' : 'active',
+                            });
+                        }
+                        catch (error) {
+                            errors.push({
+                                index,
+                                id: deletedRecordId,
+                                message: error instanceof Error ? error.message : 'Failed to restore deleted task.',
+                                statusCode: resolveErrorStatusCode(error, 400),
+                                code: error instanceof TaskforceRuleError ? error.code : error?.code,
+                            });
+                        }
+                    }
+                    return { restored, errors };
+                })();
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: error instanceof Error ? error.message : 'Failed to restore deleted tasks.',
+                code: error?.code,
+            }));
+            return;
+        }
+        const archivedCount = result.restored.filter((item) => item.restoredTo === 'archived').length;
+        const activeCount = result.restored.length - archivedCount;
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: result.errors.length === 0,
+            summary: {
+                requested: ids.length,
+                succeeded: result.restored.length,
+                failed: result.errors.length,
+                restoredToArchived: archivedCount,
+                restoredToActive: activeCount,
+            },
+            results: result.restored,
+            errors: result.errors,
+        }));
+    };
+    addRoute('POST', '/api/taskforce/deleted/restore-batch', handleRestoreDeletedTaskBatch);
+    addRoute('POST', '/api/taskforce/trash/restore-batch', handleRestoreDeletedTaskBatch);
     const handlePermanentlyDeleteDeletedTaskRoute = async (req, res, params) => {
         if (!ensureAppAccess(req, res))
             return;
@@ -922,36 +1469,86 @@ export function registerTaskRoutes(deps) {
     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;
+        try {
+            const body = await parseJsonBody(req);
+            const { text, commentId, timestamp } = body;
+            if (!text) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Comment text is required', code: 'TASK_COMMENT_INVALID' }));
+                return;
+            }
+            const workspaceId = requestWorkspaceId(req);
+            const durableRouters = createTaskHttpDurableRouters({ core, context, req, workspaceId });
+            const { comments: durableRouter, actorRef } = durableRouters;
+            let updated;
+            if (durableRouter.enabled) {
+                const result = durableRouter.append({
+                    taskId: params.id,
+                    comment: {
+                        id: String(commentId || `comment-${randomUUID()}`),
+                        author: actorRef,
+                        submittedAuthor: actorRef,
+                        text: String(text),
+                        timestamp: String(timestamp || new Date().toISOString()),
+                    },
+                });
+                updated = result.task;
+            }
+            else {
+                updated = core.addComment(params.id, String(text), actorRef, workspaceId, { actorRef });
+            }
+            if (!updated) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Task not found', code: 'TASK_NOT_FOUND' }));
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(updated));
         }
-        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;
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const retryAt = typeof error?.retryAt === 'string'
+                ? String(error.retryAt)
+                : null;
+            const retryAfterSeconds = retryAt && Number.isFinite(Date.parse(retryAt))
+                ? Math.max(0, Math.ceil((Date.parse(retryAt) - Date.now()) / 1_000))
+                : null;
+            res.writeHead(statusCode, {
+                'Content-Type': 'application/json',
+                ...(retryAfterSeconds !== null ? { 'Retry-After': String(retryAfterSeconds) } : {}),
+            });
+            res.end(JSON.stringify({
+                error: error instanceof Error ? error.message : 'Failed to add comment.',
+                ...(error?.code ? { code: String(error.code) } : {}),
+                ...(retryAt ? { retryAt } : {}),
+            }));
         }
-        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;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const durableRouter = createTaskHttpRootRouter(req, workspaceId);
+            const restored = durableRouter.enabled
+                ? durableRouter.unarchive(params.id)
+                : 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));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to unarchive task';
+            const errorCode = error?.code;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message, code: errorCode }));
         }
-        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
@@ -966,12 +1563,27 @@ export function registerTaskRoutes(deps) {
             return;
         }
         const workspaceId = requestWorkspaceId(req);
-        const result = core.bulkCreateTasks(tasks, {
-            atomic: atomic !== false,
-            validateOnly: validate_only === true,
-            workspaceId,
-            provisionalLocalReference: shouldUseProvisionalTaskReferences(requestRuntimeMode(req))
-        });
+        const durableRouters = createTaskHttpDurableRouters({ core, context, req, workspaceId });
+        let result;
+        try {
+            result = !durableRouters.root.enabled || validate_only === true
+                ? core.bulkCreateTasks(tasks, {
+                    atomic: atomic !== false,
+                    validateOnly: validate_only === true,
+                    workspaceId,
+                    provisionalLocalReference: shouldUseProvisionalTaskReferences(requestRuntimeMode(req))
+                })
+                : createTaskHttpBulkRouter(req, workspaceId).create(tasks, atomic !== false);
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: error instanceof Error ? error.message : 'Failed to create tasks',
+                code: error?.code,
+            }));
+            return;
+        }
         const hasErrors = result.errors.length > 0;
         const succeeded = validate_only ? (hasErrors ? 0 : result.total) : result.created.length;
         const summary = buildBatchSummary({
@@ -1004,29 +1616,45 @@ export function registerTaskRoutes(deps) {
             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 workspaceId = requestWorkspaceId(req);
+        const durableRouters = createTaskHttpDurableRouters({ core, context, req, workspaceId });
+        let batchResult;
+        try {
+            batchResult = durableRouters.root.enabled
+                ? createTaskHttpBulkRouter(req, workspaceId).archive(ids, status)
+                : (() => {
+                    const archived = [];
+                    const errors = [];
+                    for (let i = 0; i < ids.length; i += 1) {
+                        const taskId = ids[i];
+                        try {
+                            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
+                            });
+                        }
+                    }
+                    return { archived, errors };
+                })();
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'Failed to archive tasks', code: error?.code }));
+            return;
         }
+        const { archived, errors } = batchResult;
         const summary = buildBatchSummary({
             operation: 'bulk-archive',
             total: ids.length,
@@ -1054,41 +1682,51 @@ export function registerTaskRoutes(deps) {
             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
-                });
-            }
+        const durableRouters = createTaskHttpDurableRouters({ core, context, req, workspaceId });
+        let batchResult;
+        try {
+            batchResult = durableRouters.root.enabled || durableRouters.checklist.enabled || durableRouters.attachmentLinks.enabled
+                ? durableRouters.bulk.updateFields(updates)
+                : (() => {
+                    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, ...(skipped.id ? { id: skipped.id } : {}),
+                                message: skipped.message, statusCode: skipped.statusCode,
+                                ...(skipped.code ? { code: skipped.code } : {}),
+                            });
+                    }
+                    for (const item of preview.toApply) {
+                        try {
+                            const updated = core.updateTask(item.id, item.fields, workspaceId);
+                            if (updated)
+                                results.push(updated);
+                            else
+                                errors.push({ index: item.index, id: item.id, message: 'Task not found', statusCode: 404, code: 'TASK_NOT_FOUND' });
+                        }
+                        catch (error) {
+                            errors.push({
+                                index: item.index,
+                                id: item.id,
+                                message: error instanceof Error ? error.message : 'Failed to update task',
+                                statusCode: resolveErrorStatusCode(error, 400),
+                                code: error instanceof TaskforceRuleError ? error.code : error?.code
+                            });
+                        }
+                    }
+                    return { preview, results, errors };
+                })();
         }
-        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
-                });
-            }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'Failed to update tasks', code: error?.code }));
+            return;
         }
+        const { preview, results, errors } = batchResult;
         const summary = buildBatchSummary({
             operation: 'bulk-update-fields',
             total: updates.length,
@@ -1165,7 +1803,22 @@ export function registerTaskRoutes(deps) {
         }
         try {
             const workspaceId = requestWorkspaceId(req);
-            const result = core.createInitiativeFromTemplate(body, workspaceId);
+            const rootRouter = createTaskHttpRootRouter(req, workspaceId);
+            const result = rootRouter.enabled
+                ? (() => {
+                    const prepared = core.buildInitiativeTemplateTaskInputs(body, workspaceId);
+                    const batch = createTaskHttpBulkRouter(req, workspaceId).create(prepared.tasks, true, 'initiative-template-create');
+                    if (batch.errors.length > 0 || batch.created.length !== prepared.tasks.length) {
+                        const first = batch.errors[0];
+                        throw new TaskforceRuleError(first?.message || 'Failed to create initiative from template.', first?.statusCode || 400, first?.code || 'INITIATIVE_TEMPLATE_CREATE_FAILED', first?.details);
+                    }
+                    return {
+                        templateId: prepared.templateId,
+                        initiative: batch.created[0],
+                        milestones: batch.created.slice(1),
+                    };
+                })()
+                : core.createInitiativeFromTemplate(body, workspaceId);
             res.writeHead(201, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 success: true,
@@ -1201,6 +1854,77 @@ export function registerTaskRoutes(deps) {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ packs }));
     });
+    addRoute('POST', '/api/taskforce/taxonomy-library/apply', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const body = await parseJsonBody(req);
+            const pack = getBuiltInTaxonomyLibraryPack(String(body?.packId || ''));
+            if (!pack)
+                throw new TaskforceRuleError('Taxonomy library pack not found.', 404, 'TAXONOMY_LIBRARY_PACK_NOT_FOUND');
+            const sections = body?.sections;
+            if (!sections || typeof sections !== 'object' || Array.isArray(sections)) {
+                throw new TaskforceRuleError('Taxonomy library sections are required.', 400, 'TAXONOMY_LIBRARY_REQUEST_INVALID');
+            }
+            const sectionKeys = Object.keys(sections);
+            if (sectionKeys.some((key) => !['categories', 'types', 'priorities'].includes(key))
+                || sectionKeys.some((key) => typeof sections[key] !== 'boolean')
+                || (body?.remapExistingValuesToDefault !== undefined && typeof body.remapExistingValuesToDefault !== 'boolean')) {
+                throw new TaskforceRuleError('Taxonomy library request contains invalid fields.', 400, 'TAXONOMY_LIBRARY_REQUEST_INVALID');
+            }
+            const selected = {
+                categories: sections.categories === true,
+                types: sections.types === true,
+                priorities: sections.priorities === true,
+            };
+            if (!selected.categories && !selected.types && !selected.priorities) {
+                throw new TaskforceRuleError('Select at least one taxonomy library section.', 400, 'TAXONOMY_LIBRARY_REQUEST_INVALID');
+            }
+            const remap = body?.remapExistingValuesToDefault === true;
+            const runtimeMode = context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req);
+            const router = createDurableTaxonomyMutationRouter({
+                core,
+                runtimeMode,
+                surface: 'http',
+                tenantId: core.getTenantId(),
+                workspaceId,
+            });
+            if (!router.enabled) {
+                throw new TaskforceRuleError('Atomic taxonomy library application is not enabled yet.', 409, 'WORKSPACE_SYNC_V3_TAXONOMY_ACTIVATION_DISABLED');
+            }
+            const result = router.mutateState(() => {
+                const current = serializeTaxonomyStateForSync(core.getTaxonomyState(workspaceId));
+                const nextCategories = selected.categories
+                    ? (remap ? pack.categories : [
+                        ...pack.categories,
+                        ...current.categories.filter((entry) => !pack.categories.some((candidate) => candidate.value === entry.value))
+                            .map((entry) => ({ ...entry, disabled: true })),
+                    ])
+                    : current.categories;
+                const nextTypes = selected.types
+                    ? (remap ? pack.types : [
+                        ...pack.types,
+                        ...current.types.filter((entry) => !pack.types.some((candidate) => candidate.value === entry.value))
+                            .map((entry) => ({ ...entry, status: 'retired' })),
+                    ])
+                    : current.types;
+                return {
+                    ...current,
+                    categories: nextCategories,
+                    types: nextTypes,
+                    priorities: selected.priorities
+                        ? pack.priorities.map((entry) => ({ ...entry, value: Number(entry.value) }))
+                        : current.priorities,
+                };
+            }, { remapIncompatibleTasks: remap });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, taxonomyState: result.taxonomyState }));
+        }
+        catch (error) {
+            writeTaxonomyMutationError(res, error);
+        }
+    });
     // 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))
@@ -1221,11 +1945,19 @@ export function registerTaskRoutes(deps) {
     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 }));
+        try {
+            const workspaceId = requestWorkspaceId(req);
+            const body = await parseJsonBody(req);
+            const requested = body?.displayLabels || {};
+            const durable = mutateTaxonomyThroughDurableBoundary(req, workspaceId, { field: 'displayLabels', value: requested });
+            const displayLabels = durable?.taxonomyState.displayLabels
+                || core.updateTaxonomyDisplayLabels(requested, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, displayLabels }));
+        }
+        catch (error) {
+            writeTaxonomyMutationError(res, error);
+        }
     });
     // GET /api/taskforce/categories - Get project categories
     addRoute('GET', '/api/taskforce/categories', async (req, res) => {
@@ -1248,9 +1980,16 @@ export function registerTaskRoutes(deps) {
             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) }));
+        try {
+            const durable = mutateTaxonomyThroughDurableBoundary(req, workspaceId, { field: 'categories', value: categories }, { remapIncompatibleTasks: true });
+            if (!durable)
+                core.updateCategories(categories, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, categories: durable?.taxonomyState.categories || core.getCategories(workspaceId) }));
+        }
+        catch (error) {
+            writeTaxonomyMutationError(res, error);
+        }
     });
     // GET /api/taskforce/types - Get project task types
     addRoute('GET', '/api/taskforce/types', async (req, res) => {
@@ -1273,9 +2012,16 @@ export function registerTaskRoutes(deps) {
             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) }));
+        try {
+            const durable = mutateTaxonomyThroughDurableBoundary(req, workspaceId, { field: 'types', value: types });
+            if (!durable)
+                core.updateTypes(types, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, types: durable?.taxonomyState.types || core.getTypes(workspaceId) }));
+        }
+        catch (error) {
+            writeTaxonomyMutationError(res, error);
+        }
     });
     // GET /api/taskforce/priorities - Get project priority levels
     addRoute('GET', '/api/taskforce/priorities', async (req, res) => {
@@ -1298,32 +2044,16 @@ export function registerTaskRoutes(deps) {
             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;
+        try {
+            const durable = mutateTaxonomyThroughDurableBoundary(req, workspaceId, { field: 'priorities', value: priorities });
+            if (!durable)
+                core.updatePriorities(priorities, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, priorities: durable?.taxonomyState.priorities || core.getPriorities(workspaceId) }));
+        }
+        catch (error) {
+            writeTaxonomyMutationError(res, error);
         }
-        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) => {
@@ -1346,8 +2076,15 @@ export function registerTaskRoutes(deps) {
             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) }));
+        try {
+            const durable = mutateTaxonomyThroughDurableBoundary(req, workspaceId, { field: 'taxonomies', value: taxonomies });
+            if (!durable)
+                core.updateTaxonomies(taxonomies, workspaceId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, taxonomies: durable?.taxonomyState.taxonomies || core.getTaxonomies(workspaceId) }));
+        }
+        catch (error) {
+            writeTaxonomyMutationError(res, error);
+        }
     });
 }