@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/server/routes/syncV3OperationRoutes.js

@@ -27,11 +27,11 @@ import { parseWorkspaceSyncV3OriginActor, } from '../../sync/v3/workspaceSyncV3O
 import { validateWorkspaceSyncV3TaskCommentReconcileProvenance, verifyWorkspaceSyncV3TaskCommentReconcileProvenance, } from '../../sync/v3/taskCommentReconcileProvenance.js';
 import { isStrongWorkspaceSyncV3OriginAssertionProfileToken, verifyWorkspaceSyncV3OriginAssertion, WORKSPACE_SYNC_V3_ORIGIN_ASSERTION_HEADER, workspaceSyncV3OriginAssertionBinding, } from '../../sync/v3/workspaceSyncV3OriginAssertion.js';
 import { validateWorkflowRuntimeMutationCommand } from '../../sync/v3/workflowRuntimeSync.js';
-import { resolveWorkflowRuntimeMutationCapability } from '../../sync/v3/durableWorkflowRuntimeMutationRouter.js';
-import { normalizeWorkflowAssignmentSyncRecord, WorkflowAssignmentSyncError, } from '../../sync/v3/workflowAssignmentSync.js';
+import { resolveWorkflowRuntimeDurableTransportCapability } from '../../sync/v3/durableWorkflowRuntimeMutationRouter.js';
+import { normalizeTaskStatusOperationWithWorkflowAssignment, WorkflowAssignmentSyncError, } from '../../sync/v3/workflowAssignmentSync.js';
 import { WorkflowAssignmentSyncConflictError } from '../../storage/workflowStore.js';
 import { DurableTaskCommentMutationError } from '../../sync/v3/taskCommentMutationService.js';
-import { DurableTaskChecklistMutationError } from '../../sync/v3/taskChecklistMutationService.js';
+import { DurableTaskChecklistMutationError, validateTaskChecklistItemUpdateIntent, } from '../../sync/v3/taskChecklistMutationService.js';
 import { DurableTaskAttachmentLinksMutationError } from '../../sync/v3/taskAttachmentLinksMutationService.js';
 import { validateWorkspaceSyncV3TaskAttachmentLinksPayload, validateWorkspaceSyncV3TaskChecklistPayload, validateWorkspaceSyncV3TaskCommentsPayload, } from '../../sync/v3/workspaceSyncV3NestedTaskCodecs.js';
 import { parseJsonBody } from './primitives.js';
@@ -157,9 +157,13 @@ export function parseWorkspaceSyncV3OperationEnvelope(body) {
     const payload = requireObject(operation.payload, 'operation.payload');
     if (operation.domain === 'task' && operation.mutationKind === 'metadata-update') {
         const saveSource = payload.saveSource;
+        const expectedDetailRevision = payload.expectedDetailRevision === undefined
+            ? undefined
+            : requireId(payload.expectedDetailRevision, 'operation.payload.expectedDetailRevision');
         assertExactKeys(payload, [
             'patch',
             ...(saveSource === undefined ? [] : ['saveSource']),
+            ...(expectedDetailRevision === undefined ? [] : ['expectedDetailRevision']),
             ...(payload.originActor === undefined ? [] : ['originActor']),
         ], 'operation.payload');
         if (saveSource !== undefined && saveSource !== 'manual' && saveSource !== 'autosave') {
@@ -173,6 +177,7 @@ export function parseWorkspaceSyncV3OperationEnvelope(body) {
                 payload: {
                     patch: requireObject(payload.patch, 'operation.payload.patch'),
                     ...(saveSource ? { saveSource } : {}),
+                    ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
                     ...(originActor ? { originActor } : {}),
                 },
             } };
@@ -363,7 +368,9 @@ export function parseWorkspaceSyncV3OperationEnvelope(body) {
         assertExactKeys(payload, [
             ...baseKeys,
             ...(payload.workflowAssignment === undefined ? [] : ['workflowAssignment']),
+            ...(payload.reviewHandoff === undefined ? [] : ['reviewHandoff']),
             ...(payload.originActor === undefined ? [] : ['originActor']),
+            ...(payload.expectedDetailRevision === undefined ? [] : ['expectedDetailRevision']),
         ], 'operation.payload');
         const normalizedPayload = validateDurableTaskStatusMutationPayload({
             status: payload.status,
@@ -371,9 +378,8 @@ export function parseWorkspaceSyncV3OperationEnvelope(body) {
             canceledReason: payload.canceledReason,
             metadataPatch: payload.metadataPatch,
         });
-        const workflowAssignment = payload.workflowAssignment === undefined
-            ? undefined
-            : normalizeWorkflowAssignmentSyncRecord(payload.workflowAssignment);
+        const normalizedOperationPayload = normalizeTaskStatusOperationWithWorkflowAssignment(payload);
+        const workflowAssignment = normalizedOperationPayload.workflowAssignment;
         if (workflowAssignment
             && (normalizedPayload.status !== 'in-progress'
                 || workflowAssignment.execution.taskId !== entityId)) {
@@ -382,12 +388,19 @@ export function parseWorkspaceSyncV3OperationEnvelope(body) {
         const originActor = payload.originActor === undefined
             ? undefined
             : requireOriginActor(payload.originActor);
+        const expectedDetailRevision = payload.expectedDetailRevision === undefined
+            ? undefined
+            : requireId(payload.expectedDetailRevision, 'operation.payload.expectedDetailRevision');
         return { ...common, operation: {
                 domain: 'task', entityId, mutationKind: 'set-status', baseEntityRevision, baseLifecycleRevision,
                 payload: {
                     ...normalizedPayload,
                     ...(workflowAssignment ? { workflowAssignment } : {}),
+                    ...(normalizedOperationPayload.reviewHandoff
+                        ? { reviewHandoff: normalizedOperationPayload.reviewHandoff }
+                        : {}),
                     ...(originActor ? { originActor } : {}),
+                    ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
                 },
             } };
     }
@@ -450,7 +463,24 @@ export function parseWorkspaceSyncV3OperationEnvelope(body) {
         if (baseLifecycleRevision !== '0') {
             throw new SyncV3RequestError('Task checklist lifecycle revision must be 0.');
         }
-        assertExactKeys(payload, payload.originActor === undefined ? ['items'] : ['items', 'originActor'], 'operation.payload');
+        const expectedDetailRevision = payload.expectedDetailRevision === undefined
+            ? undefined
+            : requireId(payload.expectedDetailRevision, 'operation.payload.expectedDetailRevision');
+        let itemUpdateIntent;
+        try {
+            itemUpdateIntent = payload.itemUpdateIntent === undefined
+                ? undefined
+                : validateTaskChecklistItemUpdateIntent(payload.itemUpdateIntent);
+        }
+        catch (error) {
+            throw new SyncV3RequestError(error instanceof Error ? error.message : 'operation.payload.itemUpdateIntent is invalid.');
+        }
+        assertExactKeys(payload, [
+            'items',
+            ...(expectedDetailRevision === undefined ? [] : ['expectedDetailRevision']),
+            ...(itemUpdateIntent === undefined ? [] : ['itemUpdateIntent']),
+            ...(payload.originActor === undefined ? [] : ['originActor']),
+        ], 'operation.payload');
         let items;
         try {
             items = validateWorkspaceSyncV3TaskChecklistPayload({ taskId: entityId, items: payload.items }).items;
@@ -464,7 +494,12 @@ export function parseWorkspaceSyncV3OperationEnvelope(body) {
         return { ...common, operation: {
                 domain: 'task-checklist', entityId, mutationKind: 'replace', baseEntityRevision,
                 baseLifecycleRevision: '0',
-                payload: { items, ...(originActor ? { originActor } : {}) },
+                payload: {
+                    items,
+                    ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
+                    ...(itemUpdateIntent ? { itemUpdateIntent } : {}),
+                    ...(originActor ? { originActor } : {}),
+                },
             } };
     }
     if (operation.domain === 'task-attachment-links' && operation.mutationKind === 'replace') {
@@ -720,7 +755,7 @@ export function registerWorkspaceSyncV3OperationRoutes(input) {
     const taxonomyEnabled = input.taxonomyEnabled ?? isWorkspaceSyncV3TaxonomyEnabled();
     const initiativeEnabled = input.initiativeEnabled ?? isWorkspaceSyncV3InitiativesEnabled();
     const workstreamEnabled = input.workstreamEnabled ?? isWorkspaceSyncV3WorkstreamsEnabled();
-    const workflowRuntimeEnabled = input.workflowRuntimeEnabled ?? resolveWorkflowRuntimeMutationCapability({
+    const workflowRuntimeEnabled = input.workflowRuntimeEnabled ?? resolveWorkflowRuntimeDurableTransportCapability({
         runtimeMode: 'cloud',
         surface: 'http',
         env: input.env,
@@ -1016,6 +1051,7 @@ export function registerWorkspaceSyncV3OperationRoutes(input) {
                     operationId: envelope.operationId,
                     errorCode: String(error?.code || 'POST_COMMIT_EFFECT_FAILED').slice(0, 100),
                 }),
+                includeWorkflowRuntimeJournal: workflowRuntimeEnabled,
             };
             const operationWasCommitted = Boolean(store.readCommittedOperationResponse({
                 tenantId: input.core.getTenantId(),

package/dist/server/routes/tasks.js

@@ -69,6 +69,7 @@ import { createDurableWorkstreamMutationRouter } from '../../sync/v3/durableWork
 import { createDurableWorkstreamTaskOrderMutationRouter } from '../../sync/v3/durableWorkstreamTaskOrderMutationRouter.js';
 import { serializeCanonicalPlanningAttachmentLinks } from '../../sync/planningCanonicalFields.js';
 import { createTaskHttpDurableRouters } from './durableTaskHttpRouters.js';
+import { WorkspaceSyncDurabilityStore } from '../../sync/v3/syncDurabilityStore.js';
 // === SECTION: Module dependency interface ===
 const UI_STATE_MAX_JSON_BODY_BYTES = 50 * 1024 * 1024;
 function normalizeDurableChecklistItems(input) {
@@ -470,15 +471,89 @@ export function registerTaskRoutes(deps) {
             res,
             route: '/api/taskforce/tasks',
             workspaceId,
-            load: () => core.listTasks(workspaceId),
+            // Local V2 sync still builds an outbound snapshot from these collections.
+            // Keep its full graph until that writer is retired; cloud is read-authoritative.
+            load: () => (context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req)) === 'cloud'
+                ? core.listActiveTaskSummaries(workspaceId)
+                : core.listTasks(workspaceId),
         });
     });
+    // GET /api/taskforce/tasks/search - Search lightweight task summaries across lifecycles
+    addRoute('GET', '/api/taskforce/tasks/search', async (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        try {
+            const requestUrl = new URL(req.url || '', 'http://localhost');
+            const query = String(requestUrl.searchParams.get('query') || '').trim();
+            if (!query) {
+                throw new TaskforceRuleError('query is required.', 400, 'TASK_SEARCH_QUERY_REQUIRED');
+            }
+            if (query.length > 200) {
+                throw new TaskforceRuleError('query must be 200 characters or fewer.', 400, 'TASK_SEARCH_QUERY_TOO_LONG');
+            }
+            const scopeInput = String(requestUrl.searchParams.get('scope') || 'all').trim();
+            if (!['all', 'active', 'archive'].includes(scopeInput)) {
+                throw new TaskforceRuleError('scope must be all, active, or archive.', 400, 'TASK_SEARCH_SCOPE_INVALID');
+            }
+            const parseBoundedInteger = (name, fallback, max) => {
+                const raw = requestUrl.searchParams.get(name);
+                if (raw === null || raw === '')
+                    return fallback;
+                const parsed = Number(raw);
+                if (!Number.isInteger(parsed) || parsed < (name === 'limit' ? 1 : 0) || parsed > max) {
+                    throw new TaskforceRuleError(`${name} must be an integer between ${name === 'limit' ? 1 : 0} and ${max}.`, 400, `TASK_SEARCH_${name.toUpperCase()}_INVALID`);
+                }
+                return parsed;
+            };
+            const limit = parseBoundedInteger('limit', 50, 50);
+            const offset = parseBoundedInteger('offset', 0, 10_000);
+            const workspaceId = requestWorkspaceId(req);
+            const rows = core.searchTaskSummaries(query, scopeInput, workspaceId, { limit: limit + 1, offset });
+            const hasMore = rows.length > limit;
+            const matches = rows.slice(0, limit);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                matches,
+                pagination: {
+                    limit,
+                    offset,
+                    returned: matches.length,
+                    hasMore,
+                    nextOffset: hasMore ? offset + matches.length : null,
+                },
+            }));
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const message = error instanceof Error ? error.message : 'Failed to search tasks.';
+            const code = error instanceof TaskforceRuleError ? error.code : error?.code;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: message, code }));
+        }
+    });
     addRoute('GET', '/api/taskforce/task-relationships', async (req, res) => {
         if (!ensureAppAccess(req, res))
             return;
         const workspaceId = requestWorkspaceId(req);
+        const relationships = core.listTaskRelationshipsForSync(workspaceId);
+        const requestUrl = new URL(req.url || '', 'http://localhost');
+        const includeSyncCoordinates = requestUrl.searchParams.get('includeSyncCoordinates') === 'true';
+        const durabilityStore = includeSyncCoordinates
+            ? new WorkspaceSyncDurabilityStore(core.getDatabaseAdapter())
+            : null;
+        const syncCoordinates = durabilityStore
+            ? Object.fromEntries(relationships.map((relationship) => [
+                relationship.id,
+                durabilityStore.readEntityRevisionCoordinates({
+                    tenantId: core.getTenantId(),
+                    workspaceId,
+                    domain: 'task-relationship',
+                    entityId: relationship.id,
+                }),
+            ]))
+            : undefined;
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ relationships: core.listTaskRelationshipsForSync(workspaceId) }));
+        res.end(JSON.stringify({ relationships, ...(syncCoordinates ? { syncCoordinates } : {}) }));
     });
     const handleListDeletedTasks = async (req, res) => {
         if (!ensureAppAccess(req, res))
@@ -544,7 +619,8 @@ export function registerTaskRoutes(deps) {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ dataVersion }));
     });
-    // GET /api/taskforce/health - Lightweight readiness signal for API + DB
+    // GET /api/taskforce/health - Bounded, non-mutating readiness signal for API + DB.
+    // `/api/taskforce/version` remains the dependency-free process/build liveness signal.
     addRoute('GET', '/api/taskforce/health', async (req, res) => {
         const healthy = core.isDatabaseHealthy();
         const payload = {
@@ -617,6 +693,20 @@ export function registerTaskRoutes(deps) {
             }));
         }
     });
+    // GET /api/taskforce/task/:id - Read complete active or archived task detail
+    addRoute('GET', '/api/taskforce/task/:id', async (req, res, params) => {
+        if (!ensureAppAccess(req, res))
+            return;
+        const workspaceId = requestWorkspaceId(req);
+        const task = core.getTaskDetailSnapshot(params.id, workspaceId);
+        if (!task) {
+            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(task));
+    });
     // PATCH /api/taskforce/task/:id - Update a task
     addRoute('PATCH', '/api/taskforce/task/:id', async (req, res, params) => {
         if (!ensureAppAccess(req, res))
@@ -625,8 +715,15 @@ export function registerTaskRoutes(deps) {
         try {
             const workspaceId = requestWorkspaceId(req);
             const saveSource = body?.saveSource === 'autosave' ? 'autosave' : 'manual';
+            const expectedDetailRevision = typeof body?.expectedDetailRevision === 'string'
+                ? body.expectedDetailRevision.trim()
+                : null;
+            if (body && Object.prototype.hasOwnProperty.call(body, 'expectedDetailRevision')
+                && !expectedDetailRevision) {
+                throw new TaskforceRuleError('expectedDetailRevision must be a non-empty string.', 400, 'TASK_DETAIL_REVISION_INVALID');
+            }
             const updates = body && typeof body === 'object'
-                ? Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'saveSource'))
+                ? Object.fromEntries(Object.entries(body).filter(([key]) => (key !== 'saveSource' && key !== 'expectedDetailRevision')))
                 : body;
             const durableRouters = createTaskHttpDurableRouters({ core, context, req, workspaceId });
             const durableRouter = durableRouters.root;
@@ -658,10 +755,14 @@ export function registerTaskRoutes(deps) {
             const durableTargetCount = Number(checklistDurable)
                 + Number(attachmentLinksDurable)
                 + Number(Object.keys(remainingUpdates).length > 0);
-            if (durableTargetCount > 1) {
+            if (durableTargetCount > 1 || Boolean(expectedDetailRevision && (checklistDurable || attachmentLinksDurable))) {
                 const aggregate = durableRouters.bulk.updateFields([
                     { id: params.id, ...updates },
-                ], { saveSource, atomicItemFailures: true });
+                ], {
+                    saveSource,
+                    atomicItemFailures: true,
+                    ...(expectedDetailRevision ? { expectedDetailRevision } : {}),
+                });
                 const failure = aggregate.errors[0];
                 if (failure) {
                     throw new TaskforceRuleError(failure.message, failure.statusCode, failure.code || 'TASK_UPDATE_FAILED', failure.details);
@@ -671,11 +772,13 @@ export function registerTaskRoutes(deps) {
             else {
                 updated = Object.keys(remainingUpdates || {}).length > 0
                     ? (durableRouter.enabled
-                        ? durableRouter.update(params.id, remainingUpdates, saveSource)
-                        : core.updateTask(params.id, remainingUpdates, workspaceId, {
-                            actorRef: requestHumanActorRef(req),
-                            saveSource,
-                        }))
+                        ? durableRouter.update(params.id, remainingUpdates, saveSource, undefined, expectedDetailRevision || undefined)
+                        : expectedDetailRevision !== null
+                            ? core.updateTaskIfDetailRevisionMatches(params.id, expectedDetailRevision, remainingUpdates, workspaceId, { actorRef: requestHumanActorRef(req), saveSource })
+                            : core.updateTask(params.id, remainingUpdates, workspaceId, {
+                                actorRef: requestHumanActorRef(req),
+                                saveSource,
+                            }))
                     : core.getTask(params.id, workspaceId);
                 if (updated && checklistDurable) {
                     const checklistRouter = durableRouters.createChecklistRouter(durableRouters.deriveChildOperationId('task-patch-checklist', 0, params.id));
@@ -711,8 +814,14 @@ export function registerTaskRoutes(deps) {
                 res.end(JSON.stringify({ error: 'Task not found' }));
                 return;
             }
+            const authoritative = core.getTaskDetailSnapshot(params.id, workspaceId);
+            if (!authoritative) {
+                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));
+            res.end(JSON.stringify(authoritative));
         }
         catch (error) {
             const statusCode = resolveErrorStatusCode(error, 400);
@@ -1291,7 +1400,9 @@ export function registerTaskRoutes(deps) {
             res,
             route: '/api/taskforce/archive',
             workspaceId,
-            load: () => core.listArchive(workspaceId),
+            load: () => (context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req)) === 'cloud'
+                ? core.listArchiveSummaries(workspaceId)
+                : core.listArchive(workspaceId),
         });
     });
     // POST /api/taskforce/task/:id/complete - Archive as complete

package/dist/server/routes/workflows.js

@@ -8,7 +8,7 @@ import { WorkflowStore } from '../../storage/workflowStore.js';
 import { createDurableTaskHttpRootMutationRouter } from '../../sync/v3/durableTaskHttpRootMutationRouter.js';
 import { fingerprintWorkspaceSyncPayload, WorkspaceSyncDurabilityStore, } from '../../sync/v3/syncDurabilityStore.js';
 import { normalizeWorkflowAssignmentSyncRecord } from '../../sync/v3/workflowAssignmentSync.js';
-import { createDurableWorkflowRuntimeMutationRouter, resolveWorkflowRuntimeMutationCapability, } from '../../sync/v3/durableWorkflowRuntimeMutationRouter.js';
+import { areWorkflowRuntimeMutationsFenced, createDurableWorkflowRuntimeMutationRouter, resolveWorkflowRuntimeMutationCapability, } from '../../sync/v3/durableWorkflowRuntimeMutationRouter.js';
 import { parseJsonBody, resolveHttpErrorStatusCode } from './primitives.js';
 import { requestRuntimeMode } from './shared.js';
 function writeJson(res, statusCode, payload) {
@@ -94,6 +94,14 @@ export function registerWorkflowRoutes(deps) {
     const executionMutationGuard = (req, res) => {
         if (!guard(req, res))
             return false;
+        if (areWorkflowRuntimeMutationsFenced()) {
+            writeJson(res, 503, {
+                success: false,
+                error: 'Workflow execution changes are temporarily paused.',
+                code: 'WORKFLOW_RUNTIME_MUTATIONS_FENCED',
+            });
+            return false;
+        }
         return durableWorkflowHttpEnabled(req) || requireCloudRuntime(res, 'Workflow execution');
     };
     const workspaceIdFor = (req) => String(requestWorkspaceId(req) || '').trim() || 'default';

package/dist/server/routes/workspaces.js

@@ -17,9 +17,11 @@ import { parseJsonBody } from './primitives.js';
 import { resolveRequestAccess, createSessionTokenCookie, resolveSessionCookieAttributesForRequest, } from '../auth.js';
 import { isWorkspaceSwitchingEnabledForRuntime } from '../../shared/runtimeContract.js';
 import { getRouteTimingNow, logSlowBootstrapRoute, requestBootstrapTraceId, resolveErrorStatusCode, serializeJsonWithTiming, setServerTimingHeader } from './shared.js';
+import { WorkspaceDeletionAdmission } from '../workspaceDeletionAdmission.js';
 // === SECTION: Registration ===
 export function registerWorkspaceRoutes(deps) {
     const { addRoute, core, context, ensureAppAccess, auditAuthAction, getObjectStorageClient, ensureWithinDir, sanitizeStorageSegment, sanitizeTaskIdForPath, normalizeDocumentPathInput, } = deps;
+    const workspaceDeletionAdmission = new WorkspaceDeletionAdmission();
     // === SECTION: Storage cleanup helper ===
     const cleanupDeletedWorkspaceStorage = async (summary) => {
         const warnings = [];
@@ -231,12 +233,49 @@ export function registerWorkspaceRoutes(deps) {
             res.end(JSON.stringify({ success: false, error: 'workspaceId is required.', code: 'WORKSPACE_ID_REQUIRED' }));
             return;
         }
-        const resolvedAccess = core.resolveUserAccess(access.userId, targetWorkspaceId, 'member');
+        const writeAdmissionError = (decision) => {
+            res.setHeader('Retry-After', String(Math.max(1, Math.ceil(decision.retryAfterMs / 1_000))));
+            const inProgress = decision.code === 'WORKSPACE_DELETE_IN_PROGRESS';
+            res.writeHead(inProgress ? 409 : 429, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: inProgress
+                    ? 'Workspace deletion is already running for this workspace.'
+                    : 'Workspace deletion was attempted recently. Wait before retrying.',
+                code: decision.code,
+                retryAfterMs: decision.retryAfterMs,
+            }));
+        };
+        const existingAdmission = workspaceDeletionAdmission.checkExisting(targetWorkspaceId);
+        if (existingAdmission) {
+            writeAdmissionError(existingAdmission);
+            return;
+        }
+        let resolvedAccess;
+        try {
+            resolvedAccess = core.resolveUserAccess(access.userId, targetWorkspaceId, 'member');
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: String(error?.message || 'Unable to resolve workspace access'),
+                code: error?.code,
+            }));
+            return;
+        }
         if (!resolvedAccess || resolvedAccess.role !== 'owner' || resolvedAccess.disabled) {
             res.writeHead(403, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ success: false, error: 'Only workspace owners can delete this workspace.' }));
             return;
         }
+        const deletionAdmissionKey = targetWorkspaceId;
+        const admission = workspaceDeletionAdmission.acquire(deletionAdmissionKey);
+        if (!admission.allowed) {
+            writeAdmissionError(admission);
+            return;
+        }
         try {
             const deleted = core.deleteWorkspace({ workspaceId: targetWorkspaceId });
             const cleanupWarnings = await cleanupDeletedWorkspaceStorage(deleted);
@@ -277,6 +316,9 @@ export function registerWorkspaceRoutes(deps) {
                 code: error?.code
             }));
         }
+        finally {
+            workspaceDeletionAdmission.settle(deletionAdmissionKey);
+        }
     });
     // === SECTION: Session workspace switch ===
     // POST /api/taskforce/session/workspace - Switch active workspace in auth session

package/dist/server/routes.js

@@ -27,11 +27,15 @@ import { registerTaskRoutes } from './routes/tasks.js';
 import { registerWorkspaceRoutes } from './routes/workspaces.js';
 import { registerAuthRoutes } from './routes/auth.js';
 import { registerAdminRoutes } from './routes/admin.js';
+import { registerGitHubReviewEvidenceRoutes } from './routes/githubReviewEvidence.js';
+import { registerExecutorPhaseAApprovalRoutes } from './routes/executorPhaseAApprovals.js';
+import { registerExecutorPhaseAIssuerRedemptionRoutes } from './routes/executorPhaseAIssuerRedemptions.js';
 import { registerResourceRoutes } from './routes/resources.js';
 import { registerDocumentRoutes } from './routes/documents.js';
 import { registerDocumentReviewRoutes } from './routes/documentReviews.js';
 import { registerAnnotatedAttachmentRoutes } from './routes/annotatedAttachments.js';
 import { registerAgentsRoutes } from './routes/agents.js';
+import { registerModelConnectionsRoutes } from './routes/modelConnections.js';
 import { registerAgentRolesRoutes } from './routes/agentRoles.js';
 import { registerAgentSkillsRoutes } from './routes/agentSkills.js';
 import { registerWorkflowRoutes } from './routes/workflows.js';
@@ -40,6 +44,8 @@ import { createAgentRoleBehaviorReferenceResolver } from '../services/agentRoleR
 import { registerLocalMcpHealthRoutes } from './routes/localMcpHealth.js';
 import { registerLocalUpdateRoutes } from './routes/localUpdate.js';
 import { registerLocalServiceRoutes } from './routes/localService.js';
+import { createGitHubReviewEvidenceRuntime } from '../services/githubReviewEvidenceRuntime.js';
+import { createExecutorPhaseAApprovalRuntime } from '../services/executorPhaseAApprovalRuntime.js';
 import { escapeHtml } from './routes/primitives.js';
 import { getRouteEmailConfig, resolvePublicAuthBaseUrl, resolveRuntimeConfigBaseUrl, shouldExposeDevAuthTokens } from './routes/authSupport.js';
 import { requestHeader, requestRole, requestRuntimeMode, requestUserId, makeAuditAdminAction, makeAuditAuthAction, makeEnsureAdminRole, makeEnsureAppAccess, makeEnsureAuthenticatedUser, makeEnsureCloudPlanData, makeRequestWorkspaceId, makeRequireCloudRuntime, makeResolveAdminRequestActor, makeResolveAuthenticatedUserId, makeResolveAuthenticatedMutationUserId, } from './routes/shared.js';
@@ -1443,6 +1449,51 @@ export function createRoutes(core, context = {}) {
         normalizeDocumentPathInput,
     });
     registerLocalServiceRoutes({ addRoute, core, context: context.localService });
+    const githubReviewEvidence = createGitHubReviewEvidenceRuntime(core);
+    registerGitHubReviewEvidenceRoutes({
+        addRoute,
+        store: githubReviewEvidence.store,
+        configured: githubReviewEvidence.configured,
+        inspectInstallation: (installationId) => githubReviewEvidence.verifier.inspectInstallation(installationId),
+        requestWorkspaceId,
+        requestRole,
+        resolveAuthenticatedUserId,
+        ensureAppAccess,
+        ensureWorkspaceAdminRole,
+        ensureAdminRole,
+        requireCloudRuntime,
+        auditAuthAction,
+    });
+    const executorPhaseAApprovals = createExecutorPhaseAApprovalRuntime(core);
+    registerExecutorPhaseAApprovalRoutes({
+        addRoute,
+        service: executorPhaseAApprovals.service,
+        requireCloudRuntime,
+        ensureAppAccess,
+        resolveHumanSystemAdminActor: (req) => {
+            if (!context.authConfig?.enabled)
+                return null;
+            const access = resolveRequestAccess(req, context.authConfig);
+            if (!access.authenticated || !access.userId || access.userId === 'anonymous')
+                return null;
+            return core.getSystemRole(access.userId) === 'system_admin' ? access.userId : null;
+        },
+        hasActiveWorkspaceMembership: (workspaceId, userId) => core.listWorkspaceUsers(workspaceId).some((membership) => (String(membership.userId || '').trim() === userId
+            && String(membership.status || '').trim().toLowerCase() === 'active'
+            && membership.disabled !== true)),
+        auditAuthAction,
+        workspaceId: executorPhaseAApprovals.policy.workspaceId,
+        allowedOrigin: executorPhaseAApprovals.policy.issuer,
+        performanceEnvironment: resolveDeploymentConfig(process.env).cloudEnvironment === 'performance',
+    });
+    registerExecutorPhaseAIssuerRedemptionRoutes({
+        addRoute,
+        requireCloudRuntime,
+        performanceEnvironment: resolveDeploymentConfig(process.env).cloudEnvironment === 'performance',
+        featureEnabled: String(process.env.TASKFORCE_PHASE_A_ISSUER_REDEMPTION_ENABLED || '').trim().toLowerCase() === 'true',
+        auditAuthAction,
+        workspaceId: executorPhaseAApprovals.policy.workspaceId,
+    });
     registerAdminRoutes({
         addRoute,
         core,
@@ -1452,6 +1503,7 @@ export function createRoutes(core, context = {}) {
         requestRole,
         ensureAppAccess,
         ensureAdminRole,
+        ensureWorkspaceAdminRole,
         ensureCloudPlanData,
         requireCloudRuntime,
         resolveAuthenticatedUserId,
@@ -1565,6 +1617,13 @@ export function createRoutes(core, context = {}) {
             resolveBehaviorReference: createAgentRoleBehaviorReferenceResolver(new AgentRoleStore(core.getDatabaseAdapter(), core.getTenantId()), workspaceId),
         }),
     });
+    registerModelConnectionsRoutes({
+        addRoute,
+        ensureAppAccess,
+        core,
+        resolveAuthenticatedUserId,
+        resolveRuntimeMode: (req) => (context.authConfig?.runtimeMode === 'cloud' ? 'cloud' : requestRuntimeMode(req)),
+    });
     registerAgentRolesRoutes({
         addRoute,
         ensureAppAccess,

package/dist/server/workspaceDeletionAdmission.d.ts

@@ -0,0 +1,23 @@
+export declare const WORKSPACE_DELETE_RETRY_COOLDOWN_MS = 30000;
+export type WorkspaceDeletionAdmissionDecision = {
+    allowed: true;
+} | {
+    allowed: false;
+    code: 'WORKSPACE_DELETE_IN_PROGRESS' | 'WORKSPACE_DELETE_RETRY_COOLDOWN';
+    retryAfterMs: number;
+};
+/**
+ * Serializes destructive workspace cleanup inside one server process and
+ * throttles immediate retries after an attempt settles. The caller supplies
+ * time so the admission policy can be verified without timers.
+ */
+export declare class WorkspaceDeletionAdmission {
+    private readonly cooldownMs;
+    private readonly entries;
+    constructor(cooldownMs?: number);
+    checkExisting(key: string, now?: number): Exclude<WorkspaceDeletionAdmissionDecision, {
+        allowed: true;
+    }> | null;
+    acquire(key: string, now?: number): WorkspaceDeletionAdmissionDecision;
+    settle(key: string, now?: number): void;
+}

package/dist/server/workspaceDeletionAdmission.js

@@ -0,0 +1,50 @@
+export const WORKSPACE_DELETE_RETRY_COOLDOWN_MS = 30_000;
+/**
+ * Serializes destructive workspace cleanup inside one server process and
+ * throttles immediate retries after an attempt settles. The caller supplies
+ * time so the admission policy can be verified without timers.
+ */
+export class WorkspaceDeletionAdmission {
+    cooldownMs;
+    entries = new Map();
+    constructor(cooldownMs = WORKSPACE_DELETE_RETRY_COOLDOWN_MS) {
+        this.cooldownMs = cooldownMs;
+    }
+    checkExisting(key, now = Date.now()) {
+        let existing = this.entries.get(key);
+        if (existing?.state === 'cooldown' && existing.retryAt <= now) {
+            this.entries.delete(key);
+            existing = undefined;
+        }
+        if (existing?.state === 'in-flight') {
+            return {
+                allowed: false,
+                code: 'WORKSPACE_DELETE_IN_PROGRESS',
+                retryAfterMs: Math.max(1_000, this.cooldownMs),
+            };
+        }
+        if (existing?.state === 'cooldown') {
+            return {
+                allowed: false,
+                code: 'WORKSPACE_DELETE_RETRY_COOLDOWN',
+                retryAfterMs: Math.max(1_000, existing.retryAt - now),
+            };
+        }
+        return null;
+    }
+    acquire(key, now = Date.now()) {
+        const existing = this.checkExisting(key, now);
+        if (existing)
+            return existing;
+        this.entries.set(key, { state: 'in-flight' });
+        return { allowed: true };
+    }
+    settle(key, now = Date.now()) {
+        if (this.entries.get(key)?.state !== 'in-flight')
+            return;
+        this.entries.set(key, {
+            state: 'cooldown',
+            retryAt: now + this.cooldownMs,
+        });
+    }
+}