@taskforcehq/taskforce 0.3.328 → 0.3.329

package/dist/mcp/taskPlanningRegistrar.js

@@ -11,8 +11,16 @@ function nullableStringProperty(description) {
         ],
     };
 }
-function numberProperty(description) {
-    return { type: 'number', description };
+function integerProperty(description, minimum, maximum) {
+    return {
+        type: 'integer',
+        description,
+        ...(minimum === undefined ? {} : { minimum }),
+        ...(maximum === undefined ? {} : { maximum }),
+    };
+}
+function integerEnumProperty(description, values) {
+    return { type: 'integer', description, enum: values };
 }
 function booleanProperty(description) {
     return { type: 'boolean', description };
@@ -57,7 +65,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                         title: stringProperty('Initiative title.'),
                         description: stringProperty('Optional initiative description.'),
                         ownerId: stringProperty(`${context.assigneeHint} Call list_assignees to inspect eligible IDs.`),
-                        order: numberProperty('Optional initiative order.'),
+                        order: integerProperty('Optional non-negative initiative order.', 0),
                     },
                     required: ['title'],
                 },
@@ -71,7 +79,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                             title: stringProperty('Workstream title.'),
                             description: stringProperty('Optional workstream description.'),
                             ownerId: stringProperty(`${context.assigneeHint} Call list_assignees to inspect eligible IDs.`),
-                            order: numberProperty('Optional workstream order.'),
+                            order: integerProperty('Optional non-negative workstream order.', 0),
                             tasks: {
                                 type: 'array', maxItems: 50,
                                 items: {
@@ -83,8 +91,8 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                                         assignee: stringProperty(`${context.assigneeHint} Call list_assignees to inspect eligible IDs.`),
                                         category: stringProperty('Task category.', context.categoryEnum),
                                         type: stringProperty('Task type.', context.typeEnum),
-                                        priority: numberProperty(context.priorityDesc),
-                                        complexity: numberProperty(context.complexityDesc),
+                                        priority: integerEnumProperty(context.priorityDesc, context.priorityEnum),
+                                        complexity: integerProperty(context.complexityDesc, 1, 5),
                                         scheduledDate: stringProperty('Optional schedule date (YYYY-MM-DD).'),
                                         dueDate: stringProperty('Optional due date (YYYY-MM-DD).'),
                                     },
@@ -120,22 +128,24 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 status: stringProperty('Filter by status.', ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']),
                 openOnly: booleanProperty('When true, only include open tasks (task, on-hold, in-progress, review).'),
                 assignee: stringProperty(context.assigneeHint),
-                priority: numberProperty('Filter by priority level.'),
+                priority: integerEnumProperty(context.priorityDesc, context.priorityEnum),
                 type: stringProperty('Filter by task type.', context.typeEnum),
                 workstreamId: stringProperty('Filter by workstream ID or workstream reference such as WS-123.'),
                 sort: stringProperty('Sort field (default: created).', ['priority', 'created', 'updated']),
                 order: stringProperty('Sort order (default: desc).', ['asc', 'desc']),
-                limit: numberProperty('Max tasks to return.'),
-                offset: numberProperty('Non-negative result offset for pagination (default: 0).'),
+                limit: integerProperty('Max tasks to return (max 200).', 1, 200),
+                offset: integerProperty('Non-negative result offset for pagination (default: 0).', 0),
             },
         },
     }));
     register('search_tasks', (context) => ({
-        description: context.describeTool('Search active and archived tasks by keyword, ID, T-* reference, or provisional LT-* reference. Use scope to narrow results. Prefer this over list_tasks when looking for a specific task by name. When results include links, preserve those links when presenting tasks.'),
+        description: context.describeTool('Search active and archived tasks by keyword, ID, T-* reference, or provisional LT-* reference. Use scope to narrow results and offset/limit to continue broad searches. Prefer this over list_tasks when looking for a specific task by name. When results include links, preserve those links when presenting tasks.'),
         inputSchema: {
             properties: {
                 query: stringProperty('Search term or exact task reference such as T-123 or LT-123.'),
                 scope: stringProperty('Search scope (default: all).', ['all', 'active', 'archive']),
+                limit: integerProperty('Page size (default 25; max 50).', 1, 50),
+                offset: integerProperty('Non-negative result offset (default 0).', 0),
             },
             required: ['query'],
         },
@@ -179,10 +189,12 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
         },
     }));
     register('list_initiatives', (context) => ({
-        description: context.describeTool('List or search initiatives for the active workspace. Pass query to search by initiative title, description, ID/reference, owner, or linked workstream title. Returns compact initiative summaries with workstream and task counts.'),
+        description: context.describeTool('List or search initiatives for the active workspace. Pass query to search by initiative title, description, ID/reference, owner, or linked workstream title. Use offset/limit to continue through compact summaries.'),
         inputSchema: {
             properties: {
                 query: stringProperty('Optional search term for initiative title, description, ID/reference such as IN-123, owner, or linked workstream title.'),
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Page size (default 25; max 100).' },
+                offset: { type: 'integer', minimum: 0, description: 'Non-negative result offset (default 0).' },
             },
         },
     }));
@@ -205,7 +217,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 title: stringProperty('Initiative title.'),
                 description: stringProperty('Optional initiative description.'),
                 ownerId: stringProperty(context.assigneeHint),
-                order: numberProperty('Optional sort order among initiatives.'),
+                order: integerProperty('Optional non-negative sort order among initiatives.', 0),
                 attachments: arrayProperty('Optional attachment descriptors to store on the initiative. Prefer save_initiative_attachment for generated content or files.', {
                     type: 'object',
                     properties: {
@@ -231,7 +243,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 title: stringProperty('Updated initiative title.'),
                 description: stringProperty('Updated initiative description.'),
                 ownerId: stringProperty(context.assigneeHint),
-                order: numberProperty('Optional sort order among initiatives.'),
+                order: integerProperty('Optional non-negative sort order among initiatives.', 0),
                 attachments: arrayProperty('Replacement attachment descriptors for the initiative. Prefer save_initiative_attachment for generated content or files. Removing managed attachments requires delete_initiative_attachment in the extended profile.', {
                     type: 'object',
                     properties: {
@@ -278,10 +290,12 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
         },
     }));
     register('list_workstreams', (context) => ({
-        description: context.describeTool('List or search workstreams for the active workspace. Pass query to search by workstream title, description, ID/reference, owner, or linked initiative title/reference. Returns compact workstream summaries with task counts.'),
+        description: context.describeTool('List or search workstreams for the active workspace. Pass query to search by workstream title, description, ID/reference, owner, or linked initiative title/reference. Use offset/limit to continue through compact summaries.'),
         inputSchema: {
             properties: {
                 query: stringProperty('Optional search term for workstream title, description, ID/reference such as WS-123, owner, or linked initiative title/reference.'),
+                limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Page size (default 25; max 100).' },
+                offset: { type: 'integer', minimum: 0, description: 'Non-negative result offset (default 0).' },
             },
         },
     }));
@@ -305,7 +319,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 description: stringProperty('Optional workstream description.'),
                 ownerId: stringProperty(context.assigneeHint),
                 initiativeId: stringProperty('Optional initiative ID or initiative reference such as IN-123.'),
-                order: numberProperty('Optional sort order among workstreams.'),
+                order: integerProperty('Optional non-negative sort order among workstreams.', 0),
                 attachments: arrayProperty('Optional attachment descriptors to store on the workstream. Prefer save_workstream_attachment for generated content or files.', {
                     type: 'object',
                     properties: {
@@ -332,7 +346,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 description: stringProperty('Updated workstream description.'),
                 ownerId: stringProperty(context.assigneeHint),
                 initiativeId: stringProperty('Optional initiative ID or initiative reference such as IN-123. Pass an empty string to unlink.'),
-                order: numberProperty('Optional sort order among workstreams.'),
+                order: integerProperty('Optional non-negative sort order among workstreams.', 0),
                 attachments: arrayProperty('Replacement attachment descriptors for the workstream. Prefer save_workstream_attachment for generated content or files. Removing managed attachments requires delete_workstream_attachment in the extended profile.', {
                     type: 'object',
                     properties: {
@@ -384,9 +398,9 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
         inputSchema: {
             properties: {
                 taskId: stringProperty('Task ID or task reference such as T-123.'),
-                id: stringProperty('Alias for taskId. Task ID or task reference such as T-123.'),
                 workstreamId: nullableStringProperty('Workstream ID or workstream reference such as WS-123. Pass an empty string or null to unlink.'),
             },
+            required: ['taskId', 'workstreamId'],
         },
     }));
     register('update_workstream_initiative', (context) => ({
@@ -394,9 +408,9 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
         inputSchema: {
             properties: {
                 workstreamId: stringProperty('Workstream ID or workstream reference such as WS-123.'),
-                id: stringProperty('Alias for workstreamId. Workstream ID or workstream reference such as WS-123.'),
                 initiativeId: nullableStringProperty('Initiative ID or initiative reference such as IN-123. Pass an empty string or null to unlink.'),
             },
+            required: ['workstreamId', 'initiativeId'],
         },
     }));
     register('get_task_checklist', (context) => ({
@@ -430,7 +444,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                         id: { type: 'string', description: 'Stable checklist item ID. Reuse it when reordering or updating an existing item.' },
                         text: { type: 'string' },
                         done: { type: 'boolean' },
-                        order: { type: 'number', description: 'Optional zero-based display order.' },
+                        order: { type: 'integer', minimum: 0, description: 'Optional zero-based display order.' },
                         createdAt: { type: 'string', description: 'Optional canonical ISO creation timestamp.' },
                         updatedAt: { type: 'string', description: 'Optional canonical ISO last-change timestamp.' },
                     },
@@ -454,28 +468,17 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
         inputSchema: {
             properties: {
                 taskId: stringProperty('Task ID or task reference such as T-123.'),
-                id: stringProperty('Alias for taskId.'),
                 date: nullableStringProperty('YYYY-MM-DD; null or empty with taskId unschedules.'),
-                scheduledDate: nullableStringProperty('Alias for date.'),
-                order: numberProperty('Optional position within that day.'),
-                orderInDay: numberProperty('Alias for order.'),
+                order: integerProperty('Optional non-negative position within that day.', 0),
                 taskIds: arrayProperty('Ordered task IDs or references replacing one day.', { type: 'string' }),
-                moves: arrayProperty('Advanced reorder moves using task, date, and order aliases.', {
+                moves: arrayProperty('Advanced reorder moves using canonical taskId, date, and order fields.', {
                     type: 'object',
                     properties: {
-                        id: { type: 'string' },
                         taskId: { type: 'string' },
                         date: { type: 'string' },
-                        scheduledDate: { type: 'string' },
-                        order: { type: 'number' },
-                        orderInDay: { type: 'number' },
+                        order: { type: 'integer', minimum: 0 },
                     },
-                    anyOf: [
-                        { required: ['id', 'date'] },
-                        { required: ['id', 'scheduledDate'] },
-                        { required: ['taskId', 'date'] },
-                        { required: ['taskId', 'scheduledDate'] },
-                    ],
+                    required: ['taskId', 'date'],
                 }),
             },
         },
@@ -535,9 +538,9 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 workstreamId: stringProperty('Workstream ID or WS-123; use to create the task directly inside a workstream. Search list_workstreams if needed.'),
                 category: stringProperty('Task category value.', context.categoryEnum),
                 type: stringProperty('Task type value.', context.typeEnum),
-                priority: numberProperty(context.priorityDesc),
+                priority: integerEnumProperty(context.priorityDesc, context.priorityEnum),
                 status: stringProperty('Initial task status.', ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']),
-                complexity: numberProperty(context.complexityDesc),
+                complexity: integerProperty(context.complexityDesc, 1, 5),
                 scheduledDate: stringProperty('Optional scheduled date in YYYY-MM-DD format.'),
                 dueDate: stringProperty('Optional due date in YYYY-MM-DD format.'),
             },
@@ -574,9 +577,9 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 workstreamId: stringProperty('Updated workstream ID or workstream reference such as WS-123. Pass an empty string to unlink the task. Call list_workstreams with query first if you only know the workstream name.'),
                 category: stringProperty('Updated category value.', context.categoryEnum),
                 type: stringProperty('Updated task type value.', context.typeEnum),
-                priority: numberProperty(context.priorityDesc),
+                priority: integerEnumProperty(context.priorityDesc, context.priorityEnum),
                 status: stringProperty('Updated task status.', ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']),
-                complexity: numberProperty(context.complexityDesc),
+                complexity: integerProperty(context.complexityDesc, 1, 5),
                 scheduledDate: stringProperty('Updated scheduled date in YYYY-MM-DD format. Pass an empty string to clear.'),
                 dueDate: stringProperty('Updated due date in YYYY-MM-DD format. Pass an empty string to clear.'),
             },

package/dist/mcp/toolCallCompatibility.js

@@ -10,7 +10,44 @@ export function resolveCanonicalMcpToolName(nameRaw) {
 export function resolveMcpToolCallCompatibility(nameRaw, argsRaw) {
     const name = resolveCanonicalMcpToolName(nameRaw);
     const args = argsRaw && typeof argsRaw === 'object' && !Array.isArray(argsRaw)
-        ? argsRaw
+        ? { ...argsRaw }
         : {};
+    const moveAlias = (alias, canonical) => {
+        if (args[canonical] === undefined && args[alias] !== undefined)
+            args[canonical] = args[alias];
+        delete args[alias];
+    };
+    if (name === 'get_image')
+        moveAlias('id', 'imageId');
+    if (name === 'get_image_annotations')
+        moveAlias('imageAssetId', 'imageId');
+    if (name === 'get_task_attachments')
+        moveAlias('id', 'taskId');
+    if (name === 'update_task_workstream')
+        moveAlias('id', 'taskId');
+    if (name === 'update_workstream_initiative')
+        moveAlias('id', 'workstreamId');
+    if (name === 'update_schedule') {
+        moveAlias('id', 'taskId');
+        moveAlias('scheduledDate', 'date');
+        moveAlias('orderInDay', 'order');
+        if (Array.isArray(args.moves)) {
+            args.moves = args.moves.map((move) => {
+                if (!move || typeof move !== 'object' || Array.isArray(move))
+                    return move;
+                const normalized = { ...move };
+                const normalizeMoveAlias = (alias, canonical) => {
+                    if (normalized[canonical] === undefined && normalized[alias] !== undefined) {
+                        normalized[canonical] = normalized[alias];
+                    }
+                    delete normalized[alias];
+                };
+                normalizeMoveAlias('id', 'taskId');
+                normalizeMoveAlias('scheduledDate', 'date');
+                normalizeMoveAlias('orderInDay', 'order');
+                return normalized;
+            });
+        }
+    }
     return { name, arguments: args };
 }

package/dist/mcp/toolCatalog.d.ts

@@ -22,6 +22,7 @@ export type McpToolDescriptorContext = {
     describeTool: (text: string) => string;
     assigneeHint: string;
     categoryEnum: string[];
+    priorityEnum: number[];
     priorityDesc: string;
     typeEnum: string[];
     complexityDesc: string;

package/dist/migrations/taskSchemaMigrations.js

@@ -1423,6 +1423,7 @@ export function buildWorkspaceSyncDurabilitySchemaSql(provider) {
             base_lifecycle_revision ${revisionType} NOT NULL DEFAULT 0,
             payload_json TEXT NOT NULL,
             payload_fingerprint TEXT NOT NULL,
+            canonical_intent_json TEXT,
             status TEXT NOT NULL DEFAULT 'pending',
             attempt_count INTEGER NOT NULL DEFAULT 0,
             initial_not_found_attempt_count INTEGER NOT NULL DEFAULT 0,
@@ -1827,6 +1828,9 @@ export function ensureWorkspaceSyncDurabilitySchema(db) {
     if (!outboxColumns.some((column) => column.name === 'initial_not_found_attempt_count')) {
         db.exec(`ALTER TABLE workspace_sync_outbox ADD COLUMN initial_not_found_attempt_count INTEGER NOT NULL DEFAULT 0`);
     }
+    if (!outboxColumns.some((column) => column.name === 'canonical_intent_json')) {
+        db.exec(`ALTER TABLE workspace_sync_outbox ADD COLUMN canonical_intent_json TEXT`);
+    }
     if (!outboxColumns.some((column) => column.name === 'owns_task_metadata')) {
         db.exec(`ALTER TABLE workspace_sync_outbox ADD COLUMN owns_task_metadata INTEGER NOT NULL DEFAULT 0`);
     }
@@ -2129,6 +2133,8 @@ export function ensureLocalSyncCoordinatorSchema(db) {
             created_at TEXT NOT NULL,
             updated_at TEXT NOT NULL,
             next_attempt_at TEXT NOT NULL,
+            terminal_at TEXT,
+            terminal_reason TEXT,
             resolved_at TEXT,
             PRIMARY KEY (tenant_id, workspace_id, task_id)
         );
@@ -2172,6 +2178,12 @@ export function ensureLocalSyncCoordinatorSchema(db) {
     if (!attachmentApplyColumns.has('revision_fingerprint')) {
         db.exec(`ALTER TABLE workspace_sync_v3_attachment_apply_obligations ADD COLUMN revision_fingerprint TEXT`);
     }
+    if (!attachmentApplyColumns.has('terminal_at')) {
+        db.exec(`ALTER TABLE workspace_sync_v3_attachment_apply_obligations ADD COLUMN terminal_at TEXT`);
+    }
+    if (!attachmentApplyColumns.has('terminal_reason')) {
+        db.exec(`ALTER TABLE workspace_sync_v3_attachment_apply_obligations ADD COLUMN terminal_reason TEXT`);
+    }
     const coordinatorStateColumns = db.provider === 'postgres'
         ? new Set(db.prepare(`
             SELECT column_name AS name

package/dist/runtime/appGateDefinitions.d.ts

@@ -1,36 +1,60 @@
 export declare const APP_GATE_DEFINITIONS: {
     readonly 'annotated_attachments.workspace_access': {
-        readonly enabled: true;
+        readonly enabledByEnvironment: {
+            readonly performance: true;
+            readonly staging: true;
+            readonly production: true;
+        };
         readonly description: "Annotated Attachment workspace readiness gate.";
         readonly owner: "taskforce";
         readonly removalMilestone: "Annotated Attachment GA";
     };
     readonly 'documents.workspace_access': {
-        readonly enabled: true;
+        readonly enabledByEnvironment: {
+            readonly performance: true;
+            readonly staging: true;
+            readonly production: true;
+        };
         readonly description: "Document Manager/editor workspace readiness gate.";
         readonly owner: "taskforce";
         readonly removalMilestone: "Document Manager GA";
     };
     readonly 'workflow_manager.workspace_access': {
-        readonly enabled: false;
+        readonly enabledByEnvironment: {
+            readonly performance: true;
+            readonly staging: true;
+            readonly production: false;
+        };
         readonly description: "Workflow Manager workspace readiness gate.";
         readonly owner: "taskforce";
         readonly removalMilestone: "Workflow Manager GA";
     };
     readonly 'taskforce_agents.workspace_access': {
-        readonly enabled: false;
+        readonly enabledByEnvironment: {
+            readonly performance: true;
+            readonly staging: true;
+            readonly production: false;
+        };
         readonly description: "Taskforce Agents workspace readiness gate.";
         readonly owner: "taskforce";
         readonly removalMilestone: "Taskforce Agents workspace GA";
     };
     readonly 'ai_profiles.workspace_access': {
-        readonly enabled: true;
+        readonly enabledByEnvironment: {
+            readonly performance: true;
+            readonly staging: true;
+            readonly production: true;
+        };
         readonly description: "AI Profiles workspace readiness gate.";
         readonly owner: "taskforce";
         readonly removalMilestone: "AI Profiles workspace GA";
     };
     readonly 'planning.workspace_access': {
-        readonly enabled: false;
+        readonly enabledByEnvironment: {
+            readonly performance: false;
+            readonly staging: false;
+            readonly production: false;
+        };
         readonly description: "Planning workspace readiness gate.";
         readonly owner: "taskforce";
         readonly removalMilestone: "Planning workspace GA";

package/dist/runtime/appGateDefinitions.js

@@ -1,36 +1,36 @@
 export const APP_GATE_DEFINITIONS = {
     'annotated_attachments.workspace_access': {
-        enabled: true,
+        enabledByEnvironment: { performance: true, staging: true, production: true },
         description: 'Annotated Attachment workspace readiness gate.',
         owner: 'taskforce',
         removalMilestone: 'Annotated Attachment GA'
     },
     'documents.workspace_access': {
-        enabled: true,
+        enabledByEnvironment: { performance: true, staging: true, production: true },
         description: 'Document Manager/editor workspace readiness gate.',
         owner: 'taskforce',
         removalMilestone: 'Document Manager GA'
     },
     'workflow_manager.workspace_access': {
-        enabled: false,
+        enabledByEnvironment: { performance: true, staging: true, production: false },
         description: 'Workflow Manager workspace readiness gate.',
         owner: 'taskforce',
         removalMilestone: 'Workflow Manager GA'
     },
     'taskforce_agents.workspace_access': {
-        enabled: false,
+        enabledByEnvironment: { performance: true, staging: true, production: false },
         description: 'Taskforce Agents workspace readiness gate.',
         owner: 'taskforce',
         removalMilestone: 'Taskforce Agents workspace GA'
     },
     'ai_profiles.workspace_access': {
-        enabled: true,
+        enabledByEnvironment: { performance: true, staging: true, production: true },
         description: 'AI Profiles workspace readiness gate.',
         owner: 'taskforce',
         removalMilestone: 'AI Profiles workspace GA'
     },
     'planning.workspace_access': {
-        enabled: false,
+        enabledByEnvironment: { performance: false, staging: false, production: false },
         description: 'Planning workspace readiness gate.',
         owner: 'taskforce',
         removalMilestone: 'Planning workspace GA'

package/dist/runtime/appGates.d.ts

@@ -1,17 +1,18 @@
-export type RuntimeMode = 'local' | 'cloud';
+import type { TaskforceCloudEnvironment } from '../config/cloudEnvironment.js';
+import { APP_GATE_DEFINITIONS as APP_GATE_CONFIG } from './appGateDefinitions.js';
 export declare const ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY: "annotated_attachments.workspace_access";
 export declare const DOCUMENT_WORKSPACE_FEATURE_KEY: "documents.workspace_access";
 export declare const WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY: "workflow_manager.workspace_access";
 export declare const TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY: "taskforce_agents.workspace_access";
 export declare const AI_PROFILES_WORKSPACE_FEATURE_KEY: "ai_profiles.workspace_access";
 export declare const PLANNING_WORKSPACE_FEATURE_KEY: "planning.workspace_access";
-export type AppGateKey = typeof ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY | typeof DOCUMENT_WORKSPACE_FEATURE_KEY | typeof WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY | typeof TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY | typeof AI_PROFILES_WORKSPACE_FEATURE_KEY | typeof PLANNING_WORKSPACE_FEATURE_KEY;
+export type AppGateKey = keyof typeof APP_GATE_CONFIG;
 export interface AppGateDefinition {
-    key: AppGateKey;
-    enabled: boolean;
-    description: string;
-    owner: string;
-    removalMilestone: string;
+    readonly key: AppGateKey;
+    readonly enabledByEnvironment: Readonly<Record<TaskforceCloudEnvironment, boolean>>;
+    readonly description: string;
+    readonly owner: string;
+    readonly removalMilestone: string;
 }
 export interface ResolvedFeatureAccess {
     featureKey: string;
@@ -20,11 +21,9 @@ export interface ResolvedFeatureAccess {
     code: string;
 }
 export type ResolvedFeatureAccessMap = Record<string, ResolvedFeatureAccess>;
-export declare const APP_GATE_DEFINITIONS: Record<AppGateKey, AppGateDefinition>;
+export declare const APP_GATE_DEFINITIONS: Readonly<Record<AppGateKey, AppGateDefinition>>;
 export declare function listAppGateDefinitions(): AppGateDefinition[];
 export declare function getAppGateDefinition(featureKey: string): AppGateDefinition | null;
-export declare function resolveAppGateAccess(featureKey: string): ResolvedFeatureAccess;
-export declare function resolveFeatureAccess(input: {
-    featureKey: string;
-    runtimeMode: RuntimeMode;
-}): ResolvedFeatureAccess;
+export declare function resolveAppGateAccess(featureKey: string, environment: TaskforceCloudEnvironment): ResolvedFeatureAccess;
+export declare function resolveAppGateAccessMap(environment: TaskforceCloudEnvironment): ResolvedFeatureAccessMap;
+export declare function isResolvedFeatureAccessMap(value: unknown): value is ResolvedFeatureAccessMap;

package/dist/runtime/appGates.js

@@ -5,16 +5,17 @@ export const WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY = 'workflow_manager.workspac
 export const TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY = 'taskforce_agents.workspace_access';
 export const AI_PROFILES_WORKSPACE_FEATURE_KEY = 'ai_profiles.workspace_access';
 export const PLANNING_WORKSPACE_FEATURE_KEY = 'planning.workspace_access';
-export const APP_GATE_DEFINITIONS = Object.entries(APP_GATE_CONFIG).reduce((acc, [key, definition]) => {
-    acc[key] = {
+const appGateDefinitions = Object.fromEntries(Object.entries(APP_GATE_CONFIG).map(([key, definition]) => [
+    key,
+    Object.freeze({
         key: key,
-        enabled: Boolean(definition.enabled),
-        description: String(definition.description || ''),
-        owner: String(definition.owner || ''),
-        removalMilestone: String(definition.removalMilestone || '')
-    };
-    return acc;
-}, {});
+        enabledByEnvironment: Object.freeze({ ...definition.enabledByEnvironment }),
+        description: definition.description,
+        owner: definition.owner,
+        removalMilestone: definition.removalMilestone,
+    }),
+]));
+export const APP_GATE_DEFINITIONS = Object.freeze(appGateDefinitions);
 export function listAppGateDefinitions() {
     return Object.values(APP_GATE_DEFINITIONS);
 }
@@ -24,7 +25,7 @@ export function getAppGateDefinition(featureKey) {
         return null;
     return APP_GATE_DEFINITIONS[normalizedKey] || null;
 }
-export function resolveAppGateAccess(featureKey) {
+export function resolveAppGateAccess(featureKey, environment) {
     const gate = getAppGateDefinition(featureKey);
     if (!gate) {
         return {
@@ -34,7 +35,7 @@ export function resolveAppGateAccess(featureKey) {
             code: 'OK'
         };
     }
-    if (!gate.enabled) {
+    if (!gate.enabledByEnvironment[environment]) {
         return {
             featureKey,
             allowed: false,
@@ -49,6 +50,21 @@ export function resolveAppGateAccess(featureKey) {
         code: 'OK'
     };
 }
-export function resolveFeatureAccess(input) {
-    return resolveAppGateAccess(input.featureKey);
+export function resolveAppGateAccessMap(environment) {
+    return Object.fromEntries(listAppGateDefinitions().map(({ key }) => [key, resolveAppGateAccess(key, environment)]));
+}
+export function isResolvedFeatureAccessMap(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const candidate = value;
+    return listAppGateDefinitions().every(({ key }) => {
+        const access = candidate[key];
+        if (!access || typeof access !== 'object' || Array.isArray(access))
+            return false;
+        const resolved = access;
+        return resolved.featureKey === key
+            && typeof resolved.allowed === 'boolean'
+            && (resolved.source === 'app_gate' || resolved.source === 'cloud_entitlement' || resolved.source === 'none')
+            && typeof resolved.code === 'string';
+    });
 }

package/dist/runtime/nodeAppGates.d.ts

@@ -0,0 +1,8 @@
+import type { TaskforceCloudEnvironment } from '../config/cloudEnvironment.js';
+import { type ResolvedFeatureAccess, type ResolvedFeatureAccessMap } from './appGates.js';
+export interface NodeAppGateResolutionOptions {
+    onWarning?: (message: string) => void;
+}
+export declare function resolveNodeAppGateEnvironment(env?: NodeJS.ProcessEnv, options?: NodeAppGateResolutionOptions): TaskforceCloudEnvironment;
+export declare function resolveNodeAppGateAccess(featureKey: string, env?: NodeJS.ProcessEnv, options?: NodeAppGateResolutionOptions): ResolvedFeatureAccess;
+export declare function resolveNodeAppGateAccessMap(env?: NodeJS.ProcessEnv, options?: NodeAppGateResolutionOptions): ResolvedFeatureAccessMap;

package/dist/runtime/nodeAppGates.js

@@ -0,0 +1,27 @@
+import { resolveDeploymentConfig } from '../config/deployment.js';
+import { resolveAppGateAccess, resolveAppGateAccessMap, } from './appGates.js';
+const warnedEnvironmentSignatures = new WeakMap();
+export function resolveNodeAppGateEnvironment(env = process.env, options = {}) {
+    const deployment = resolveDeploymentConfig(env);
+    const warnings = [...deployment.warnings];
+    if (!deployment.cloudEnvironment) {
+        warnings.push('TASKFORCE_CLOUD_ENVIRONMENT could not be resolved; using the production App Gate profile.');
+    }
+    const warningSignature = warnings.join('\n');
+    if (warnings.length === 0) {
+        warnedEnvironmentSignatures.delete(env);
+    }
+    else if (warnedEnvironmentSignatures.get(env) !== warningSignature) {
+        const onWarning = options.onWarning || ((message) => console.warn(`[Taskforce App Gates] ${message}`));
+        for (const warning of warnings)
+            onWarning(warning);
+        warnedEnvironmentSignatures.set(env, warningSignature);
+    }
+    return deployment.cloudEnvironment || 'production';
+}
+export function resolveNodeAppGateAccess(featureKey, env = process.env, options = {}) {
+    return resolveAppGateAccess(featureKey, resolveNodeAppGateEnvironment(env, options));
+}
+export function resolveNodeAppGateAccessMap(env = process.env, options = {}) {
+    return resolveAppGateAccessMap(resolveNodeAppGateEnvironment(env, options));
+}

package/dist/server/cloudCollectionRead.d.ts

@@ -18,7 +18,7 @@ export interface CloudCollectionReadResponse {
         details: Record<string, number>;
     };
 }
-type CloudCollectionReadCore = Pick<TaskforceCore, 'resolveUserAccess' | 'getSystemRole' | 'getAccountAccessStatus' | 'listTasks' | 'listArchive' | 'listDeletedTasksReadOnly' | 'listPlanningBootstrap'>;
+type CloudCollectionReadCore = Pick<TaskforceCore, 'resolveUserAccess' | 'getSystemRole' | 'getAccountAccessStatus' | 'listActiveTaskSummaries' | 'listArchiveSummaries' | 'listDeletedTasksReadOnly' | 'listPlanningBootstrap'>;
 export declare function resolveCloudCollectionReadOperation(method: string | undefined, pathname: string): CloudCollectionReadOperation | null;
 export declare function executeCloudCollectionRead(core: CloudCollectionReadCore, request: CloudCollectionReadRequest): CloudCollectionReadResponse;
 export declare function cloudCollectionReadRoute(operation: CloudCollectionReadOperation): string;

package/dist/server/cloudCollectionRead.js

@@ -63,9 +63,9 @@ export function executeCloudCollectionRead(core, request) {
         let data;
         const planningDiagnostics = {};
         if (request.operation === 'tasks')
-            data = core.listTasks(workspaceId);
+            data = core.listActiveTaskSummaries(workspaceId);
         else if (request.operation === 'archive')
-            data = core.listArchive(workspaceId);
+            data = core.listArchiveSummaries(workspaceId);
         else if (request.operation === 'deleted')
             data = core.listDeletedTasksReadOnly(workspaceId);
         else

package/dist/server/index.d.ts

@@ -8,6 +8,7 @@ import * as http from 'http';
 import { WebSocketServer } from 'ws';
 export { resolveAuthorizedWorkspaceAccess, resolveDisabledAccessError, isWorkspaceAccessRecoveryRoute, } from './authorizedWorkspaceAccess.js';
 import type { LocalServiceCloudTarget } from '../config/localServiceCloudTarget.js';
+import type { LocalServiceRuntimeContract } from '../config/localServiceRuntimeContract.js';
 import type { LocalSyncCoordinatorHost } from '../sync/coordinator/localSyncCoordinatorHost.js';
 import type { LocalSyncProcessLock } from '../sync/coordinator/localSyncProcessLock.js';
 import type { LocalDataOwnerPermit } from './localDataOwnerPermit.js';
@@ -26,6 +27,7 @@ export interface StandaloneServerOptions {
         bootstrapCapability: string;
         ownershipKey: string;
         cloudTarget: LocalServiceCloudTarget;
+        runtimeContract: LocalServiceRuntimeContract;
     };
 }
 export interface TaskforceStandaloneServer extends http.Server {
@@ -46,6 +48,7 @@ export declare const TASKFORCE_PROXY_ORIGIN_PROTO_HEADER = "x-taskforce-origin-p
 export declare const TASKFORCE_PROXY_ORIGIN_BASE_URL_HEADER = "x-taskforce-origin-base-url";
 export declare const TASKFORCE_PROXY_ORIGIN_RUNTIME_HEADER = "x-taskforce-origin-runtime";
 export declare const TASKFORCE_PROXY_CLOUD_ENVIRONMENT_HEADER = "x-taskforce-cloud-environment";
+export declare function sanitizeQaRunIdHeader(raw: unknown): string;
 export declare function shouldProxyCloudPath(pathname: string): boolean;
 export declare function shouldProxyCloudRequest(url: Pick<URL, 'pathname' | 'searchParams'>, env?: NodeJS.ProcessEnv): boolean;
 export declare function resolveCloudProxyUpstreamBaseUrl(req: http.IncomingMessage, fallbackBaseUrl: string): string;