@taskforcehq/taskforce 0.3.328 → 0.3.329

package/dist/server/index.js

@@ -16,7 +16,7 @@ import { createRoutes, matchRoute } from './routes.js';
 import { formatApiErrorResponse } from './routes/primitives.js';
 import { logSlowBootstrapRoute } from './routes/shared.js';
 import { applyCorsHeaders, getAllowedOriginsFromEnv } from './cors.js';
-import { applyPrefixedRateLimitHeaders, applyRateLimitHeaders, InMemoryRateLimiter, resolveRateLimitKey } from './rateLimit.js';
+import { applyPrefixedRateLimitHeaders, applyRateLimitHeaders, InMemoryRateLimiter, isWorkspaceSyncFeedRead, resolveRateLimitKey, } from './rateLimit.js';
 import { isRequestAuthorized, resolveAuthConfigFromEnv, resolveRequestAccess } from './auth.js';
 import { resolveAuthorizedWorkspaceAccess, resolveDisabledAccessError, } from './authorizedWorkspaceAccess.js';
 export { resolveAuthorizedWorkspaceAccess, resolveDisabledAccessError, isWorkspaceAccessRecoveryRoute, } from './authorizedWorkspaceAccess.js';
@@ -178,6 +178,12 @@ export const TASKFORCE_PROXY_ORIGIN_PROTO_HEADER = 'x-taskforce-origin-proto';
 export const TASKFORCE_PROXY_ORIGIN_BASE_URL_HEADER = 'x-taskforce-origin-base-url';
 export const TASKFORCE_PROXY_ORIGIN_RUNTIME_HEADER = 'x-taskforce-origin-runtime';
 export const TASKFORCE_PROXY_CLOUD_ENVIRONMENT_HEADER = 'x-taskforce-cloud-environment';
+export function sanitizeQaRunIdHeader(raw) {
+    const normalized = String(Array.isArray(raw) ? raw[0] : raw || '')
+        .trim()
+        .replace(/[^A-Za-z0-9._-]+/g, '-');
+    return normalized.slice(0, 128) || '-';
+}
 function shouldLogRefreshDiagnostic(pathname) {
     return REFRESH_DIAGNOSTIC_PATH_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(prefix));
 }
@@ -658,10 +664,13 @@ export function createStandaloneServer(options) {
         : (runtimeMode === 'cloud');
     const rateLimitLimit = Number.parseInt(process.env.TASKFORCE_API_RATE_LIMIT_MAX_REQUESTS || '', 10) || 120;
     const rateLimitWindowMs = Number.parseInt(process.env.TASKFORCE_API_RATE_LIMIT_WINDOW_MS || '', 10) || 60_000;
+    const syncFeedRateLimit = Number.parseInt(process.env.TASKFORCE_SYNC_FEED_RATE_LIMIT_MAX_REQUESTS || '', 10) || 600;
+    const syncFeedRateLimitWindowMs = Number.parseInt(process.env.TASKFORCE_SYNC_FEED_RATE_LIMIT_WINDOW_MS || '', 10) || 60_000;
     const webhookRateLimitMaxRequests = Number.parseInt(process.env.TASKFORCE_STRIPE_WEBHOOK_RATE_LIMIT_MAX_REQUESTS || '', 10) || 600;
     const webhookRateLimitWindowMs = Number.parseInt(process.env.TASKFORCE_STRIPE_WEBHOOK_RATE_LIMIT_WINDOW_MS || '', 10) || 60_000;
     const maxPayloadBytes = Number.parseInt(process.env.TASKFORCE_MAX_PAYLOAD_BYTES || '', 10) || 1_048_576;
     const rateLimiter = new InMemoryRateLimiter(rateLimitLimit, rateLimitWindowMs);
+    const syncFeedRateLimiter = new InMemoryRateLimiter(syncFeedRateLimit, syncFeedRateLimitWindowMs);
     const webhookRateLimiter = new InMemoryRateLimiter(webhookRateLimitMaxRequests, webhookRateLimitWindowMs);
     const resolveAuthRateLimitSettings = () => {
         const auth = core.getGlobalSettings().auth || {};
@@ -765,7 +774,8 @@ export function createStandaloneServer(options) {
         const requestId = String(req.headers['x-request-id'] || req.headers['x-railway-request-id'] || '').trim() || '-';
         const workspaceId = String(req.headers['x-taskforce-workspace-id'] || '').trim() || '-';
         const userId = String(req.headers['x-taskforce-user-id'] || '').trim() || '-';
-        console.info(`[Taskforce RefreshDiag] method=${method} path=${pathname} status=${statusCode} durationMs=${durationMs} requestId=${requestId} workspaceId=${workspaceId} userId=${userId}`);
+        const qaRunId = sanitizeQaRunIdHeader(req.headers['x-taskforce-qa-run-id']);
+        console.info(`[Taskforce RefreshDiag] method=${method} path=${pathname} status=${statusCode} durationMs=${durationMs} requestId=${requestId} workspaceId=${workspaceId} userId=${userId} qaRunId=${qaRunId}`);
     };
     // Resolve static files directory at runtime
     // Standalone UI source now lives in apps/app and builds to dist/ui.
@@ -992,7 +1002,9 @@ export function createStandaloneServer(options) {
                     });
                     const rateLimitResult = isBillingWebhook
                         ? webhookRateLimiter.check(key)
-                        : rateLimiter.check(key);
+                        : isWorkspaceSyncFeedRead(req.method, url.pathname)
+                            ? syncFeedRateLimiter.check(key)
+                            : rateLimiter.check(key);
                     if (isBillingWebhook) {
                         applyPrefixedRateLimitHeaders(res, rateLimitResult, 'X-Webhook-RateLimit');
                     }

package/dist/server/localServiceLease.d.ts

@@ -1,4 +1,5 @@
 import { type LocalServiceCloudTarget } from '../config/localServiceCloudTarget.js';
+import { type LocalServiceRuntimeContract } from '../config/localServiceRuntimeContract.js';
 import { type WindowsAclCommandRunner } from './localServiceWindowsAcl.js';
 export interface LocalServiceDescriptor {
     schemaVersion: 1;
@@ -11,6 +12,7 @@ export interface LocalServiceDescriptor {
     bootstrapCapability: string;
     publishedAt: string;
     cloudTarget?: LocalServiceCloudTarget | null;
+    runtimeContract?: LocalServiceRuntimeContract | null;
 }
 export interface LocalServiceLeaseIdentityInput {
     projectRoot: string;
@@ -30,6 +32,7 @@ export interface LocalServiceDescriptorPublication {
     protocolVersion: string;
     appVersion: string;
     cloudTarget: LocalServiceCloudTarget;
+    runtimeContract: LocalServiceRuntimeContract;
 }
 export interface LocalServiceLease {
     readonly identity: LocalServiceLeaseIdentity;

package/dist/server/localServiceLease.js

@@ -4,6 +4,7 @@ import * as net from 'net';
 import * as os from 'os';
 import * as path from 'path';
 import { parseLocalServiceCloudTarget, } from '../config/localServiceCloudTarget.js';
+import { parseLocalServiceRuntimeContract, } from '../config/localServiceRuntimeContract.js';
 import { resolveLocalSyncProcessLockIdentity } from './localDatabaseIdentity.js';
 import { ensureWindowsUserOnlyDirectoryAcl, } from './localServiceWindowsAcl.js';
 const DESCRIPTOR_SCHEMA_VERSION = 1;
@@ -168,8 +169,14 @@ function parseDescriptor(value, ownershipKey) {
     if (value.cloudTarget != null && !cloudTarget) {
         throw new Error('Local service descriptor cloud target is invalid.');
     }
+    const runtimeContract = value.runtimeContract == null
+        ? null
+        : parseLocalServiceRuntimeContract(value.runtimeContract);
+    if (value.runtimeContract != null && !runtimeContract) {
+        throw new Error('Local service descriptor runtime contract is invalid.');
+    }
     assertLoopbackEndpoint(value.endpoint);
-    return { ...value, cloudTarget };
+    return { ...value, cloudTarget, runtimeContract };
 }
 function readOptionalDescriptor(identity) {
     try {
@@ -371,6 +378,7 @@ export async function acquireLocalServiceLease(input, dependencies = {}) {
                         bootstrapCapability,
                         publishedAt: (dependencies.now?.() || new Date()).toISOString(),
                         cloudTarget: publication.cloudTarget,
+                        runtimeContract: publication.runtimeContract,
                     };
                     publishJsonFileAtomically(identity.descriptorPath, descriptor, platform);
                     return descriptor;

package/dist/server/localWorkspaceSyncServerRuntime.js

@@ -15,6 +15,7 @@ import { createWorkspaceSyncEngineServerRunnerOperations } from '../sync/engine/
 import { workspaceSyncTransferEvidenceEvent } from '../sync/engine/workspaceSyncTransferEvidence.js';
 import { createWorkspaceSyncEngineServerPushCandidateProvider, createWorkspaceSyncEngineServerSnapshotReader, } from '../sync/engine/workspaceSyncEngineServerSnapshotReader.js';
 import { readWorkspaceSyncLocalOwnershipSnapshot } from '../sync/v3/workspaceSyncLocalOwnershipSnapshot.js';
+import { resolveRequestedCombinedFeedCoverage } from '../sync/v3/combinedFeedCapability.js';
 import { resolveWorkspaceSyncV3CombinedWireContract, } from '../sync/v3/workspaceSyncV3CombinedWireContract.js';
 import { LocalWorkspaceSyncServerOutboxDispatcher, } from '../sync/v3/localWorkspaceSyncServerOutboxDispatcher.js';
 import { readWorkspaceSyncV3LocalOutboxStatus, } from '../sync/v3/workspaceSyncV3LocalOutboxStatus.js';
@@ -950,15 +951,21 @@ export class LocalWorkspaceSyncServerRuntime {
                 if (combined.owner === 'v3' && !combinedContract) {
                     throw Object.assign(new Error('The persisted combined-feed ownership contract is invalid.'), { code: 'SYNC_RUNNER_V3_OWNERSHIP_INVALID' });
                 }
+                const desiredCombinedCoverage = combined.owner === 'v3'
+                    ? resolveRequestedCombinedFeedCoverage(this.options.env || process.env)
+                    : null;
+                const desiredCombinedContract = desiredCombinedCoverage
+                    ? resolveWorkspaceSyncV3CombinedWireContract(desiredCombinedCoverage)
+                    : null;
                 return {
                     initiativeFeedActivationEnabled: ownership.initiativeProjection.owner === 'v3',
                     initiativeProjection: ownership.initiativeProjection,
                     combinedFeedActivationEnabled: combined.owner === 'v3',
                     combinedProjection: combined,
-                    ...(combinedContract
+                    ...(combinedContract && desiredCombinedContract
                         ? {
-                            combinedFeedCoverage: combinedContract.coverage,
-                            combinedFeedExcludedProjections: combinedContract.excludedProjections,
+                            combinedFeedCoverage: desiredCombinedContract.coverage,
+                            combinedFeedExcludedProjections: desiredCombinedContract.excludedProjections,
                         }
                         : {}),
                 };

package/dist/server/rateLimit.d.ts

@@ -26,5 +26,6 @@ export declare function resolveRateLimitKey(params: {
     sessionId?: string | null;
     userId?: string | null;
 }): string;
+export declare function isWorkspaceSyncFeedRead(method: string | undefined, pathname: string): boolean;
 export declare function applyRateLimitHeaders(res: ServerResponse, result: RateLimitResult): void;
 export declare function applyPrefixedRateLimitHeaders(res: ServerResponse, result: RateLimitResult, prefix: string): void;

package/dist/server/rateLimit.js

@@ -97,6 +97,10 @@ export function resolveRateLimitKey(params) {
     }
     return `ip:${ip}:${method}:${route}`;
 }
+export function isWorkspaceSyncFeedRead(method, pathname) {
+    return String(method || 'GET').trim().toUpperCase() === 'GET'
+        && pathname === '/api/taskforce/sync/v3/workspace/feed';
+}
 export function applyRateLimitHeaders(res, result) {
     res.setHeader('X-RateLimit-Limit', String(result.limit));
     res.setHeader('X-RateLimit-Remaining', String(result.remaining));

package/dist/server/realtimeSyncWs.js

@@ -68,23 +68,34 @@ export function createRealtimeSyncWsManager(core, authConfig, logger = console,
         }
         connections.delete(ws);
     };
-    const canSubscribe = (state, workspaceId) => {
+    const resolveSubscriptionAccess = (state, workspaceId) => {
         if (!workspaceId)
-            return false;
+            return 'forbidden';
         if (!authConfig.enabled || !authConfig.requiredForApi)
-            return true;
+            return 'allowed';
         if (!state.authenticated || !state.userId || state.userId === 'anonymous')
-            return false;
-        const resolved = core.resolveUserAccess(state.userId, workspaceId, state.role);
-        return Boolean(resolved?.workspaceId === workspaceId);
+            return 'forbidden';
+        try {
+            const resolved = core.resolveUserAccess(state.userId, workspaceId, state.role);
+            return resolved?.workspaceId === workspaceId ? 'allowed' : 'forbidden';
+        }
+        catch (error) {
+            logger.warn(`[Taskforce] WebSocket access check unavailable workspace=${workspaceId}: ${String(error instanceof Error ? error.message : error)}`);
+            return 'unavailable';
+        }
     };
     const closeUnauthorized = (ws, reason) => {
         logger.warn(`[Taskforce] WebSocket rejected: ${reason}`);
         ws.close(1008, reason);
     };
     const subscribeWorkspace = (ws, state, workspaceId) => {
-        if (!canSubscribe(state, workspaceId)) {
-            send(ws, { type: 'taskforce:subscription-error', workspaceId, reason: 'forbidden' });
+        const accessDecision = resolveSubscriptionAccess(state, workspaceId);
+        if (accessDecision !== 'allowed') {
+            send(ws, {
+                type: 'taskforce:subscription-error',
+                workspaceId,
+                reason: accessDecision === 'unavailable' ? 'temporarily-unavailable' : 'forbidden'
+            });
             return;
         }
         state.workspaceIds.add(workspaceId);
@@ -132,8 +143,13 @@ export function createRealtimeSyncWsManager(core, authConfig, logger = console,
             send(ws, { type: 'taskforce:replay-error', reason: 'workspace-required' });
             return;
         }
-        if (!canSubscribe(state, workspaceId)) {
-            send(ws, { type: 'taskforce:replay-error', workspaceId, reason: 'forbidden' });
+        const accessDecision = resolveSubscriptionAccess(state, workspaceId);
+        if (accessDecision !== 'allowed') {
+            send(ws, {
+                type: 'taskforce:replay-error',
+                workspaceId,
+                reason: accessDecision === 'unavailable' ? 'temporarily-unavailable' : 'forbidden'
+            });
             return;
         }
         state.workspaceIds.add(workspaceId);
@@ -191,8 +207,16 @@ export function createRealtimeSyncWsManager(core, authConfig, logger = console,
         connections.set(ws, state);
         logger.log(`[Taskforce] WebSocket client connected user=${state.userId}`);
         const initialWorkspaceId = parseWorkspaceId(access.workspaceId);
-        if (initialWorkspaceId && canSubscribe(state, initialWorkspaceId)) {
-            state.workspaceIds.add(initialWorkspaceId);
+        if (initialWorkspaceId) {
+            const accessDecision = resolveSubscriptionAccess(state, initialWorkspaceId);
+            if (accessDecision === 'unavailable') {
+                ws.close(1013, 'access-unavailable');
+                removeConnection(ws);
+                return;
+            }
+            if (accessDecision === 'allowed') {
+                state.workspaceIds.add(initialWorkspaceId);
+            }
         }
         ws.on('message', (rawData) => {
             const payload = parseJson(rawData);

package/dist/server/routes/admin.js

@@ -1953,6 +1953,7 @@ export function registerAdminRoutes(deps) {
             workspaceAssetStore,
             publishedContentResolver,
             repairMissingAssetLinks: true,
+            repairMissingContentFiles: body?.repairMissingContentFiles === true,
             aiProfiles: typeof core.listAiProfiles === 'function'
                 ? core.listAiProfiles(workspaceId, { includeArchived: true }) || []
                 : [],

package/dist/server/routes/agentRoles.js

@@ -1,4 +1,5 @@
-import { TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, resolveAppGateAccess, } from '../../runtime/appGates.js';
+import { TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, } from '../../runtime/appGates.js';
+import { resolveNodeAppGateAccess } from '../../runtime/nodeAppGates.js';
 import { AgentRoleDefinitionValidationError } from '../../shared/agentRoleDefinition.js';
 import { AgentRoleConflictError, AgentRoleNotFoundError, AgentRoleRetiredError, AgentRoleStore, } from '../../storage/agentRoleStore.js';
 import { parseJsonBody } from './primitives.js';
@@ -128,7 +129,7 @@ export function registerAgentRolesRoutes(deps) {
     const guard = (req, res) => {
         if (!ensureAppAccess(req, res))
             return false;
-        const gate = resolveAppGateAccess(TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY);
+        const gate = resolveNodeAppGateAccess(TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY);
         if (gate.allowed)
             return true;
         writeJson(res, 403, {

package/dist/server/routes/agentSkills.js

@@ -1,4 +1,5 @@
-import { TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, resolveAppGateAccess, } from '../../runtime/appGates.js';
+import { TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, } from '../../runtime/appGates.js';
+import { resolveNodeAppGateAccess } from '../../runtime/nodeAppGates.js';
 import { compileTaskforceAgentSkillPrompt } from '../../shared/taskforceAgentSkill.js';
 import { TaskforceAgentStore } from '../../storage/taskforceAgentStore.js';
 import { TaskforceAgentSkillConflictError, TaskforceAgentSkillStore, } from '../../storage/taskforceAgentSkillStore.js';
@@ -73,7 +74,7 @@ export function registerAgentSkillsRoutes(deps) {
     const ensureFeatureAccess = (req, res) => {
         if (!ensureAppAccess(req, res))
             return false;
-        const gate = resolveAppGateAccess(TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY);
+        const gate = resolveNodeAppGateAccess(TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY);
         if (gate.allowed)
             return true;
         writeJson(res, 403, {

package/dist/server/routes/agents.js

@@ -11,10 +11,12 @@
  *   POST   /api/taskforce/agents/model-gateway/test
  *   PATCH  /api/taskforce/agents/:agentId/conversations/:conversationId
  */
+import { createHash } from 'node:crypto';
 import { assignedAiProfileColor, normalizeAiProfileColor } from '../../shared/aiProfileColors.js';
 import { BedrockAnthropicMessagesModelGateway } from '../../services/bedrockAnthropicMessagesModelGateway.js';
 import { BedrockMantleModelGateway } from '../../services/bedrockMantleModelGateway.js';
 import { BedrockModelGateway } from '../../services/bedrockModelGateway.js';
+import { CodexAppServerModelGateway } from '../../services/codexAppServerModelGateway.js';
 import { saveAiProfileAvatarAssets } from '../aiProfileAvatarAssets.js';
 import { ModelGatewayConfigurationError, normalizePersistedModelGatewayMessages } from '../../services/modelGateway.js';
 import { BedrockAvatarImageProvider, buildTaskforceAgentAvatarPrompt, } from '../../services/taskforceAgentAvatarImageProvider.js';
@@ -25,10 +27,11 @@ import { TaskforceAgentSkillStore } from '../../storage/taskforceAgentSkillStore
 import { WorkflowStore } from '../../storage/workflowStore.js';
 import { WorkspaceSyncDurabilityStore } from '../../sync/v3/syncDurabilityStore.js';
 import { projectLegacyTaskforceAgentResponse } from '../../compat/taskforceAgentDefinitionCompat.js';
-import { TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, resolveAppGateAccess, } from '../../runtime/appGates.js';
+import { TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, } from '../../runtime/appGates.js';
+import { resolveNodeAppGateAccess } from '../../runtime/nodeAppGates.js';
 import { DEFAULT_TASKFORCE_AGENT_MODEL_KEY, DEFAULT_TASKFORCE_AGENT_PROVIDER_KEY, getTaskforceAgentModel, isTaskforceAgentModelVisible, labelForTaskforceAgentModel, labelForTaskforceAgentProvider, normalizeTaskforceAgentModelKey, normalizeTaskforceAgentModelSelection, normalizeTaskforceAgentProviderKey, } from '../../shared/taskforceAgentModels.js';
 import { buildTaskforceAgentRunContext } from '../../shared/taskforceAgentRunContext.js';
-import { inspectAgentDefinition } from '../../shared/taskforceAgentDefinition.js';
+import { inspectAgentDefinition, serializeCanonicalJson } from '../../shared/taskforceAgentDefinition.js';
 import { buildResolvedTaskforceAgentSystemPrompt, resolveTaskforceAgentRuntimeConfiguration, TaskforceAgentRuntimeResolutionError, } from '../../shared/taskforceAgentRuntimeResolution.js';
 import { serializeTaskforceAgentExecutionSnapshot } from '../../shared/taskforceAgentExecutionSnapshot.js';
 import { getTaskReferenceLabel } from '../../utils/taskReferences.js';
@@ -113,6 +116,11 @@ function normalizeMessages(value, fallbackPrompt) {
         return { error: 'Prompt must be 4,000 characters or less.' };
     return { messages: [{ role: 'user', content: prompt }] };
 }
+function buildManagedAgentExecutionRequestId(input) {
+    return createHash('sha256')
+        .update(serializeCanonicalJson(input))
+        .digest('hex');
+}
 function toGatewayMessages(messages) {
     return messages.map((message) => ({
         role: message.role,
@@ -122,7 +130,13 @@ function toGatewayMessages(messages) {
 function requestsWorkflowStepCompletion(messages) {
     const latestUserMessage = [...messages].reverse().find((message) => message.role === 'user');
     const content = String(latestUserMessage?.content || '').trim().toLowerCase();
-    return /^(?:please\s+|(?:can|could|would)\s+you\s+)?(?:perform\s+and\s+complete|complete|finish)\s+(?:your|the|this)\s+(?:current\s+)?workflow\s+step[.!?]*$/.test(content);
+    return /^(?:(?:hey|hi|hello)\b[^,!?]{0,80},?\s+)?(?:please\s+|(?:can|could|would)\s+you\s+)?(?:perform\s+and\s+complete|complete|finish)\s+(?:your|the|this)\s+(?:current\s+)?workflow\s+step(?:\s+(?:on|for)\s+(?:task\s+)?(?:t-\d+|[a-z0-9][a-z0-9-]{0,119}))?[.!?]*$/.test(content);
+}
+function extractLatestExplicitTaskReference(messages) {
+    const latestUserMessage = [...messages].reverse().find((message) => message.role === 'user');
+    const matches = String(latestUserMessage?.content || '').match(/\bT-\d+\b/gi) || [];
+    const references = [...new Set(matches.map((match) => match.toUpperCase()))];
+    return references.length === 1 ? references[0] : null;
 }
 function normalizeTaskId(value) {
     const taskId = String(value || '').trim();
@@ -144,6 +158,18 @@ function resolveTaskContextTask(core, workspaceId, taskId) {
     return core.getTask(taskId, workspaceId)
         || (typeof core.resolveTaskIdentifier === 'function' ? core.resolveTaskIdentifier(taskId, workspaceId) : null);
 }
+function workflowToolCallsTargetSameTask(core, workspaceId, left, right) {
+    const resolveCanonicalId = (value) => {
+        const taskId = normalizeTaskId(value);
+        if (!taskId)
+            return null;
+        const task = resolveTaskContextTask(core, workspaceId, taskId);
+        return normalizeTaskId(task?.id)?.toLowerCase() || taskId.toLowerCase();
+    };
+    const leftTaskId = resolveCanonicalId(left);
+    const rightTaskId = resolveCanonicalId(right);
+    return Boolean(leftTaskId && rightTaskId && leftTaskId === rightTaskId);
+}
 function resolveTaskScopeContext(core, workspaceId, input) {
     const taskId = String(input.taskId || '').trim();
     if (!taskId)
@@ -244,6 +270,12 @@ function createDefaultModelGateway(selection) {
     }
     const source = selection?.modelSource || model?.source || 'bedrock';
     const runtime = selection?.runtime || model?.runtime || 'bedrock-runtime';
+    if (source === 'subscription_dev' && runtime === 'subscription-dev') {
+        if (selection?.connectionScope !== 'local_dev') {
+            throw new ModelGatewayConfigurationError('Subscription-dev models require local_dev connection scope.', 'MODEL_SOURCE_UNAVAILABLE');
+        }
+        return new CodexAppServerModelGateway();
+    }
     if (source !== 'bedrock') {
         throw new ModelGatewayConfigurationError('Selected model source is not configured yet.', 'MODEL_SOURCE_NOT_IMPLEMENTED');
     }
@@ -693,7 +725,7 @@ export function registerAgentsRoutes(deps) {
     const ensureTaskforceAgentsAccess = (req, res) => {
         if (!ensureAppAccess(req, res))
             return false;
-        const gate = resolveAppGateAccess(TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY);
+        const gate = resolveNodeAppGateAccess(TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY);
         if (gate.allowed)
             return true;
         writeJson(res, 403, {
@@ -1149,9 +1181,30 @@ export function registerAgentsRoutes(deps) {
                 }
             }
             const savedConversationTaskId = savedConversation?.taskId ? normalizeTaskId(savedConversation.taskId) : null;
-            const taskId = hasTaskId ? bodyTaskId : savedConversationTaskId;
-            const taskReference = taskId ? normalizeTaskContextValue(body?.taskReference) : '';
-            const taskTitle = taskId ? normalizeTaskContextValue(body?.taskTitle) : '';
+            const explicitTaskReference = extractLatestExplicitTaskReference(normalizedMessages.messages);
+            const explicitTask = explicitTaskReference
+                ? resolveTaskContextTask(core, workspaceId, explicitTaskReference)
+                : null;
+            if (explicitTaskReference
+                && !explicitTask
+                && requestsWorkflowStepCompletion(normalizedMessages.messages)) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: `Task ${explicitTaskReference} was not found.`,
+                    code: 'TASK_NOT_FOUND',
+                });
+                return;
+            }
+            const taskId = normalizeTaskId(explicitTask?.id)
+                || (explicitTaskReference ? null : hasTaskId ? bodyTaskId : savedConversationTaskId);
+            const taskReference = taskId
+                ? normalizeTaskContextValue(getTaskReferenceLabel(explicitTask)
+                    || (explicitTask ? explicitTaskReference : null)
+                    || body?.taskReference)
+                : '';
+            const taskTitle = taskId
+                ? normalizeTaskContextValue(explicitTask?.title || body?.taskTitle)
+                : '';
             if (resolvedRuntimeConfiguration) {
                 const definition = resolvedRuntimeConfiguration.definition;
                 const draftDiffers = ((body?.providerKey !== undefined
@@ -1272,6 +1325,13 @@ export function registerAgentsRoutes(deps) {
                 allowedMutationTaskId: taskId ?? null,
                 readOnly: !savedAgent,
                 toolPolicy: resolvedRuntimeConfiguration?.definition.toolPolicy,
+                executionRequestId: buildManagedAgentExecutionRequestId({
+                    workspaceId,
+                    agentId: savedAgent?.id || agentId || null,
+                    conversationId,
+                    taskId: taskId ?? null,
+                    messages: normalizedMessages.messages,
+                }),
                 system: scopedAgentSystem,
             });
             const executionSnapshot = savedAgent && resolvedRuntimeConfiguration
@@ -1304,21 +1364,40 @@ export function registerAgentsRoutes(deps) {
                 && mcpBridge?.availableToolNames.includes('complete_workflow_step')
                 && requestsWorkflowStepCompletion(gatewayInput.messages));
             let workflowCompletionCorrectionSent = false;
+            let reservedWorkflowCompletionUsed = false;
             while (mcpBridge) {
                 if (requestedToolCall) {
-                    if (mcpToolResults.length >= MAX_MCP_TOOL_ITERATIONS)
+                    const activeToolCall = requestedToolCall;
+                    const workflowStepAlreadyCompleted = mcpToolResults.some((toolResult) => (toolResult.name === 'complete_workflow_step' && toolResult.ok));
+                    const workflowStepLoaded = activeToolCall.name === 'complete_workflow_step'
+                        && mcpToolResults.some((toolResult) => (toolResult.name === 'get_task_workflow'
+                            && toolResult.ok
+                            && workflowToolCallsTargetSameTask(core, workspaceId, toolResult.arguments?.taskId, activeToolCall.arguments?.taskId)));
+                    const canUseReservedWorkflowCompletion = Boolean(workflowCompletionRequested
+                        && !workflowStepAlreadyCompleted
+                        && !reservedWorkflowCompletionUsed
+                        && activeToolCall.name === 'complete_workflow_step'
+                        && workflowStepLoaded
+                        && unresolvedFailedMutations.size === 0);
+                    if (mcpToolResults.length >= MAX_MCP_TOOL_ITERATIONS
+                        && !canUseReservedWorkflowCompletion)
                         break;
-                    const blocksWorkflowCompletion = requestedToolCall.name === 'complete_workflow_step'
-                        && unresolvedFailedMutations.size > 0;
+                    if (mcpToolResults.length >= MAX_MCP_TOOL_ITERATIONS) {
+                        reservedWorkflowCompletionUsed = true;
+                    }
+                    const blocksWorkflowCompletion = activeToolCall.name === 'complete_workflow_step'
+                        && (!workflowStepLoaded || unresolvedFailedMutations.size > 0);
                     const unresolvedMutationNames = [...new Set(unresolvedFailedMutations.values())];
                     const toolResult = blocksWorkflowCompletion
                         ? {
-                            name: requestedToolCall.name,
-                            arguments: requestedToolCall.arguments,
+                            name: activeToolCall.name,
+                            arguments: activeToolCall.arguments,
                             ok: false,
-                            text: `Taskforce refused workflow completion because these earlier changes failed: ${unresolvedMutationNames.join(', ')}. Retry the failed changes successfully before completing the step.`,
+                            text: !workflowStepLoaded
+                                ? 'Taskforce refused workflow completion because the current workflow step was not loaded successfully. Call get_task_workflow first, perform its instructions, then retry completion.'
+                                : `Taskforce refused workflow completion because these earlier changes failed: ${unresolvedMutationNames.join(', ')}. Retry the failed changes successfully before completing the step.`,
                         }
-                        : await mcpBridge.executeToolCall(requestedToolCall);
+                        : await mcpBridge.executeToolCall(activeToolCall);
                     mcpToolResults.push(toolResult);
                     if (isTaskforceAgentMutationToolName(toolResult.name)
                         && toolResult.name !== 'complete_workflow_step') {
@@ -1349,6 +1428,17 @@ export function registerAgentsRoutes(deps) {
                         throw error;
                     }
                     requestedToolCall = mcpBridge.parseToolCall(result.text);
+                    if (toolResult.name === 'complete_workflow_step'
+                        && toolResult.ok
+                        && requestedToolCall
+                        && mcpToolResults.length >= MAX_MCP_TOOL_ITERATIONS) {
+                        result = {
+                            ...result,
+                            text: 'Workflow step completed successfully.',
+                        };
+                        requestedToolCall = null;
+                        break;
+                    }
                     continue;
                 }
                 const workflowStepCompleted = mcpToolResults.some((toolResult) => (toolResult.name === 'complete_workflow_step' && toolResult.ok));
@@ -1358,7 +1448,7 @@ export function registerAgentsRoutes(deps) {
                         role: 'user',
                         content: unresolvedFailedMutations.size > 0
                             ? `The workflow step is not complete because these Taskforce changes failed: ${[...new Set(unresolvedFailedMutations.values())].join(', ')}. Retry those exact changes successfully before calling complete_workflow_step. If they cannot succeed, respond exactly WORKFLOW_STEP_INCOMPLETE: followed by the reason.`
-                            : 'The workflow step is not authoritatively complete. If all required work succeeded, call complete_workflow_step now. Otherwise respond exactly WORKFLOW_STEP_INCOMPLETE: followed by the reason. Do not claim completion without a successful tool result.',
+                            : 'The workflow step is not authoritatively complete. Call get_task_workflow first if it has not succeeded in this response, perform the returned step instructions, then call complete_workflow_step. Otherwise respond exactly WORKFLOW_STEP_INCOMPLETE: followed by the reason. Do not claim completion without successful tool results.',
                     });
                     result = await gateway.generate({
                         ...gatewayInput,
@@ -1370,7 +1460,19 @@ export function registerAgentsRoutes(deps) {
                 break;
             }
             if (requestedToolCall) {
-                throw new Error('Taskforce tool call limit reached before the agent returned a final response.');
+                mcpToolResults.push({
+                    name: requestedToolCall.name,
+                    arguments: requestedToolCall.arguments,
+                    ok: false,
+                    text: 'Taskforce did not execute this call because the per-message tool limit was reached.',
+                });
+                result = {
+                    ...result,
+                    text: workflowCompletionRequested
+                        ? 'WORKFLOW_STEP_INCOMPLETE: Taskforce reached the per-message tool limit before finishing the workflow step. Review Tool Activity and retry.'
+                        : 'Taskforce reached the per-message tool limit. Review Tool Activity and retry.',
+                };
+                requestedToolCall = null;
             }
             if (workflowCompletionRequested && !mcpToolResults.some((toolResult) => (toolResult.name === 'complete_workflow_step' && toolResult.ok))) {
                 const incompletePrefix = 'WORKFLOW_STEP_INCOMPLETE:';

package/dist/server/routes/annotatedAttachments.js

@@ -11,7 +11,8 @@
  *   DELETE /api/taskforce/annotated-attachments/sessions/:id
  *   GET    /api/taskforce/annotated-attachments/sessions/:id/payload
  */
-import { ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY, resolveAppGateAccess, } from '../../runtime/appGates.js';
+import { ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY, } from '../../runtime/appGates.js';
+import { resolveNodeAppGateAccess } from '../../runtime/nodeAppGates.js';
 import { parseJsonBody } from './primitives.js';
 import { resolveErrorStatusCode } from './shared.js';
 import { getImageReferenceLabel, parseImageReference } from '../../utils/imageReferences.js';
@@ -37,7 +38,7 @@ export function registerAnnotatedAttachmentRoutes(deps) {
     const ensureAnnotatedAttachmentAccess = (req, res, workspaceId) => {
         if (!ensureAppAccess(req, res))
             return false;
-        const gate = resolveAppGateAccess(ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY);
+        const gate = resolveNodeAppGateAccess(ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY);
         if (gate.allowed)
             return true;
         writeJson(res, 403, {

package/dist/server/routes/auth.js

@@ -60,6 +60,7 @@ import { buildGithubAuthUrl, exchangeGithubCode } from '../auth/providers/github
 import { hasValidSession, createClearSessionCookie, createSessionTokenCookie, resolveRequestAccess, resolveSessionCookieAttributesForRequest, } from '../auth.js';
 import { sendEmail } from '../email.js';
 import { resolveDeploymentConfig } from '../../config/deployment.js';
+import { resolveNodeAppGateAccessMap } from '../../runtime/nodeAppGates.js';
 import { resolveTaskMetadataActivationCapability } from '../../sync/v3/taskMetadataActivation.js';
 import { resolveTaskCreateActivationCapability } from '../../sync/v3/taskCreateActivation.js';
 import { resolveTaskStatusActivationCapability } from '../../sync/v3/taskStatusActivation.js';
@@ -401,7 +402,7 @@ export function registerAuthRoutes(deps) {
             : 'Reset your Taskforce password';
         const text = kind === 'verify-email'
             ? `Welcome to Taskforce.\n\nYou're almost in. Enter this verification token on the verification screen to activate your account:\n\n${token}\n\nPrefer the faster route? Open the link below to verify your email automatically:\n${link}\n\nIf you didn't create a Taskforce account, you can safely ignore this email.`
-            : `Reset your Taskforce password using this link:\n${link}\n\nIf you did not request this reset, you can ignore this message.`;
+            : `Enter this password reset token on the reset screen:\n\n${token}\n\nOr reset your Taskforce password using this link:\n${link}\n\nIf you did not request this reset, you can ignore this message.`;
         const result = await sendEmail({
             to: email,
             subject,
@@ -470,6 +471,7 @@ export function registerAuthRoutes(deps) {
                 authSource: runtimeContract.authSource,
                 workspaceMode: runtimeContract.workspaceMode,
                 workspaceSwitchingEnabled: runtimeContract.workspaceSwitchingEnabled,
+                appGates: resolveNodeAppGateAccessMap(process.env),
                 syncV3
             }
         }));

package/dist/server/routes/durableTaskHttpRouters.d.ts

@@ -10,8 +10,9 @@ export declare function createTaskHttpDurableRouters(input: {
     actorRef: string;
     root: {
         enabled: boolean;
+        hasCommittedOperation(): boolean;
         create(candidate: unknown): import("../../core/Taskforce.js").TaskItem;
-        update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed"): import("../../core/Taskforce.js").TaskItem;
+        update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed", expectedDetailRevision?: string): import("../../core/Taskforce.js").TaskItem;
         runBatch<T>(routeInput: string, request: unknown, apply: (context: {
             runChild<R>(mutation: () => R): R;
             deferPostCommitNotification(notify: () => void): void;
@@ -41,6 +42,7 @@ export declare function createTaskHttpDurableRouters(input: {
         replace(args: {
             taskId: string;
             items: readonly Partial<import("../../core/Taskforce.js").ChecklistItem>[];
+            expectedDetailRevision?: string;
         }): {
             state: "pending" | "committed";
             route: "local-outbox" | "cloud-acceptance";
@@ -54,6 +56,7 @@ export declare function createTaskHttpDurableRouters(input: {
             taskId: string;
             links: readonly import("../../sync/v3/workspaceSyncV3NestedTaskCodecs.js").WorkspaceSyncV3TaskAttachmentLink[];
             cardCoverAssetId?: string | null;
+            expectedDetailRevision?: string;
         }): {
             state: "pending" | "committed";
             route: "local-outbox" | "cloud-acceptance";
@@ -66,6 +69,7 @@ export declare function createTaskHttpDurableRouters(input: {
         replace(args: {
             taskId: string;
             items: readonly Partial<import("../../core/Taskforce.js").ChecklistItem>[];
+            expectedDetailRevision?: string;
         }): {
             state: "pending" | "committed";
             route: "local-outbox" | "cloud-acceptance";
@@ -79,6 +83,7 @@ export declare function createTaskHttpDurableRouters(input: {
             taskId: string;
             links: readonly import("../../sync/v3/workspaceSyncV3NestedTaskCodecs.js").WorkspaceSyncV3TaskAttachmentLink[];
             cardCoverAssetId?: string | null;
+            expectedDetailRevision?: string;
         }): {
             state: "pending" | "committed";
             route: "local-outbox" | "cloud-acceptance";
@@ -134,6 +139,7 @@ export declare function createTaskHttpDurableRouters(input: {
         }>, options?: {
             saveSource?: "manual" | "autosave";
             atomicItemFailures?: boolean;
+            expectedDetailRevision?: string;
         }): {
             preview: import("../../core/Taskforce.js").BulkUpdateFieldsPreview;
             results: import("../../core/Taskforce.js").TaskItem[];
@@ -149,8 +155,9 @@ export declare function createTaskHttpDurableRouters(input: {
     };
     createRootRouter: (operationId?: string, deferPostCommitNotification?: (notify: () => void) => void) => {
         enabled: boolean;
+        hasCommittedOperation(): boolean;
         create(candidate: unknown): import("../../core/Taskforce.js").TaskItem;
-        update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed"): import("../../core/Taskforce.js").TaskItem;
+        update(taskIdInput: string, candidate: unknown, saveSource: "manual" | "autosave", activityAction?: "task-updated" | "task-schedule-changed", expectedDetailRevision?: string): import("../../core/Taskforce.js").TaskItem;
         runBatch<T>(routeInput: string, request: unknown, apply: (context: {
             runChild<R>(mutation: () => R): R;
             deferPostCommitNotification(notify: () => void): void;