@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/core/TaskChecklistCommandService.js

@@ -26,13 +26,21 @@ function requireMutationResult(task, taskId) {
     throw new TaskChecklistCommandError(`Task ${taskId} not found`, 'TASK_NOT_FOUND', 404, { taskId });
 }
 export function createTaskChecklistCommandService(deps) {
-    const replaceItems = (taskId, items, operationKey) => {
-        requireMutationResult(deps.replace({
+    const replaceItems = (taskId, items, operationKey, options) => {
+        const mutated = deps.replace({
             taskId,
             items,
-            operationId: deps.createId('operation', operationKey),
-        }), taskId);
-        return deps.listItems(taskId);
+            operationId: options?.operationId || deps.createId('operation', operationKey),
+            ...(options?.expectedDetailRevision
+                ? { expectedDetailRevision: options.expectedDetailRevision }
+                : {}),
+            ...(options?.requireDurableIdempotency
+                ? { requireDurableIdempotency: true }
+                : {}),
+            ...(options?.itemUpdateIntent ? { itemUpdateIntent: options.itemUpdateIntent } : {}),
+        });
+        requireMutationResult(mutated, taskId);
+        return mutated?.checklistItems || deps.listItems(taskId);
     };
     return {
         replace(input) {
@@ -107,5 +115,75 @@ export function createTaskChecklistCommandService(deps) {
                 items,
             };
         },
+        update(input) {
+            const task = deps.resolveTask(input.taskId);
+            const itemId = String(input.itemId ?? '').trim();
+            if (!itemId) {
+                throw new TaskChecklistCommandError('update_task_checklist_item requires itemId.');
+            }
+            const currentItems = deps.listItems(task.id);
+            const existingItem = currentItems.find((item) => item.id === itemId);
+            if (!existingItem) {
+                throw new TaskChecklistCommandError(`Checklist item ${itemId} was not found on task ${task.id}.`, 'TASK_CHECKLIST_ITEM_NOT_FOUND', 404, { taskId: task.id, itemId });
+            }
+            const hasTitle = input.title !== undefined || input.text !== undefined;
+            const hasCompleted = input.isCompleted !== undefined || input.done !== undefined;
+            const hasOrder = input.order !== undefined;
+            if (!hasTitle && !hasCompleted && !hasOrder) {
+                throw new TaskChecklistCommandError('update_task_checklist_item requires at least one of text, done, or order.');
+            }
+            const title = hasTitle
+                ? normalizeTitle(input.title ?? input.text, 'update_task_checklist_item text')
+                : existingItem.title;
+            const completedInput = input.isCompleted ?? input.done;
+            if (hasCompleted && typeof completedInput !== 'boolean') {
+                throw new TaskChecklistCommandError('update_task_checklist_item done must be a boolean.');
+            }
+            const isCompleted = hasCompleted ? completedInput : existingItem.isCompleted;
+            const parsedOrder = hasOrder ? Number(input.order) : existingItem.order;
+            if (hasOrder && (!Number.isInteger(parsedOrder) || parsedOrder < 0)) {
+                throw new TaskChecklistCommandError('update_task_checklist_item order must be a non-negative integer.');
+            }
+            const expectedDetailRevision = input.expectedDetailRevision === undefined
+                ? undefined
+                : String(input.expectedDetailRevision).trim();
+            if (input.expectedDetailRevision !== undefined && !expectedDetailRevision) {
+                throw new TaskChecklistCommandError('update_task_checklist_item expectedDetailRevision must contain non-whitespace text.');
+            }
+            const unchanged = existingItem.title === title
+                && existingItem.isCompleted === isCompleted
+                && existingItem.order === parsedOrder;
+            const nextItem = unchanged
+                ? existingItem
+                : {
+                    ...existingItem,
+                    title,
+                    isCompleted,
+                    order: parsedOrder,
+                    updatedAt: deps.now(),
+                };
+            const nextItems = currentItems.map((item) => item.id === itemId ? nextItem : item);
+            const items = replaceItems(task.id, nextItems, `task-checklist-update:${task.id}:${itemId}`, {
+                operationId: input.operationId,
+                expectedDetailRevision,
+                requireDurableIdempotency: input.requireDurableIdempotency,
+                ...(input.requireDurableIdempotency ? {
+                    itemUpdateIntent: {
+                        kind: 'item-update',
+                        itemId,
+                        patch: {
+                            ...(hasTitle ? { text: title } : {}),
+                            ...(hasCompleted ? { done: isCompleted } : {}),
+                            ...(hasOrder ? { order: parsedOrder } : {}),
+                        },
+                    },
+                } : {}),
+            });
+            const item = items.find((candidate) => candidate.id === itemId);
+            if (!item) {
+                throw new TaskChecklistCommandError(`Checklist item ${itemId} was not found after updating task ${task.id}.`, 'TASK_CHECKLIST_ITEM_NOT_FOUND', 404, { taskId: task.id, itemId });
+            }
+            return { taskId: task.id, item, items };
+        },
     };
 }

package/dist/core/TaskLifecycleCommandService.d.ts

@@ -30,6 +30,7 @@ export interface TaskLifecycleCommandServiceDependencies {
         updates: Record<string, unknown>;
         forceDurable?: boolean;
         assigneeIntent?: TaskLifecycleAssigneeIntent;
+        handoffComment?: string;
     }): TaskLifecycleTask;
     mutateLifecycle(input: {
         taskId: string;
@@ -40,7 +41,7 @@ export interface TaskLifecycleCommandServiceDependencies {
             reason: string | undefined;
         };
     }): TaskLifecycleTask | null;
-    resolveReviewer(task: TaskLifecycleTask): TaskLifecycleReviewerResolution;
+    resolveReviewer(task: TaskLifecycleTask, reviewer?: unknown): TaskLifecycleReviewerResolution;
 }
 export declare class TaskLifecycleCommandError extends Error {
     readonly code: string;
@@ -81,6 +82,7 @@ export declare function createTaskLifecycleCommandService(deps: TaskLifecycleCom
     finish(task: TaskLifecycleTask, input: {
         outcome: unknown;
         comment?: unknown;
+        reviewer?: unknown;
     }): FinishTaskCommandResult;
     reopen(task: TaskLifecycleTask, input: {
         activeAiProfileId: string | null | undefined;

package/dist/core/TaskLifecycleCommandService.js

@@ -88,8 +88,12 @@ export function createTaskLifecycleCommandService(deps) {
                     nextTool: 'reopen_task',
                 });
             }
+            const normalizedComment = typeof input.comment === 'string' ? input.comment.trim() : '';
+            if (normalizedOutcome === 'review' && !normalizedComment) {
+                throw new TaskLifecycleCommandError('finish_task requires a nonblank handoff comment when outcome is review.', 'TASK_FINISH_REVIEW_COMMENT_REQUIRED', 400, { taskId: task.id, outcome: normalizedOutcome });
+            }
             const reviewerResolution = normalizedOutcome === 'review'
-                ? deps.resolveReviewer(task)
+                ? deps.resolveReviewer(task, input.reviewer)
                 : undefined;
             const updated = deps.setStatus({
                 task,
@@ -99,8 +103,8 @@ export function createTaskLifecycleCommandService(deps) {
                 ...(reviewerResolution
                     ? { assigneeIntent: { kind: 'set', value: reviewerResolution.assignee } }
                     : {}),
+                ...(normalizedOutcome === 'review' ? { handoffComment: normalizedComment } : {}),
             });
-            const normalizedComment = typeof input.comment === 'string' ? input.comment.trim() : '';
             return {
                 task: updated,
                 completion: {

package/dist/core/Taskforce.d.ts

@@ -5,6 +5,7 @@ import type { DurableTaskStatusMutationPayload } from './TaskDurableStatusMutati
 import { WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
 import { resolveAdminAuditRetentionPolicy, type AdminAuditRetentionDiagnostics, type AdminAuditRetentionRun } from './AdminAuditRetentionService.js';
 import type { WorkspaceSyncV3TaskAttachmentLink } from '../sync/v3/workspaceSyncV3NestedTaskCodecs.js';
+import { type InternalUserFeatureKey } from '../shared/userFeatureGrants.js';
 import type { TaskRestoreDestination } from '../shared/taskRestoreDestination.js';
 import { type SyncEventInput } from './SyncReconciliationService.js';
 import { type FirstClassTaxonomyDisplayLabels, type NormalizedWorkspaceTaxonomyState, type WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
@@ -458,6 +459,7 @@ export type SystemRole = 'system_admin' | 'user';
 type PermissionMode = 'read-only' | 'read-write';
 type AuthTokenPurpose = 'email_verification' | 'password_reset' | 'invite_accept';
 export type McpAccessTokenScope = 'tasks:read' | 'tasks:write' | 'workspace:read';
+export type McpCloudToolProfile = 'default' | 'extended';
 type McpAccessTokenStatus = 'active' | 'revoked' | 'expired';
 export type McpOAuthProvider = 'chatgpt' | 'claude' | 'grok' | 'gemini' | 'mistral' | 'perplexity';
 type McpOAuthClientStatus = 'active' | 'revoked';
@@ -586,6 +588,7 @@ interface SystemUserRecord {
     systemRole: SystemRole;
     betaAccess: boolean;
     disabled: boolean;
+    internalFeatureGrants: InternalUserFeatureKey[];
     planId?: string | null;
     planName?: string | null;
     planVersionId?: string | null;
@@ -608,6 +611,7 @@ export interface PurgedSystemUserSummary {
     deletedMcpOauthConnectorGrantCount: number;
     deletedUiStateCount: number;
     deletedUserPreferenceCount: number;
+    deletedUserFeatureGrantCount: number;
     deletedEntitlementCount: number;
     deletedUserBillingCount: number;
     deletedUserCount: number;
@@ -772,6 +776,7 @@ export interface McpAccessTokenRecord {
     userEmail?: string | null;
     name: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     tokenPrefix: string;
     status: McpAccessTokenStatus;
     lastUsedAt?: string | null;
@@ -799,6 +804,7 @@ export interface McpAccessTokenAuthResult {
     workspaceId: string;
     userId: string;
     scopes: McpAccessTokenScope[];
+    toolProfile?: McpCloudToolProfile;
     status: McpAccessTokenStatus;
 }
 export interface McpAccessTokenInspectionResult {
@@ -808,12 +814,14 @@ export interface McpAccessTokenInspectionResult {
     userId: string;
     name: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     status: McpAccessTokenStatus;
 }
 export interface McpOAuthClientRecord {
     id: string;
     provider: McpOAuthProvider;
     clientName: string;
+    applicationType: 'native' | 'web';
     productClientId?: string | null;
     redirectUris: string[];
     status: McpOAuthClientStatus;
@@ -829,6 +837,7 @@ export interface McpOAuthConnectorGrantRecord {
     workspaceId: string;
     userId: string;
     scopes: McpAccessTokenScope[];
+    toolProfile: McpCloudToolProfile;
     tokenPrefix: string;
     status: McpOAuthGrantStatus;
     lastUsedAt?: string | null;
@@ -851,6 +860,7 @@ export interface McpOAuthAccessTokenAuthResult {
     provider: McpOAuthProvider;
     productClientId?: string | null;
     scopes: McpAccessTokenScope[];
+    toolProfile?: McpCloudToolProfile;
     status: McpOAuthGrantStatus;
     aiProfileId?: string | null;
     aiProfileToken?: string | null;
@@ -964,7 +974,9 @@ export interface TaskforceSyncCapable {
     upsertInitiativeForSync(initiative: InitiativeItem, workspaceId?: string | null): InitiativeItem;
     upsertWorkstreamForSync(workstream: WorkstreamItem, workspaceId?: string | null): WorkstreamItem;
     upsertDocumentReviewSessionForSync(session: DocumentReviewSessionRecord): DocumentReviewSessionRecord;
-    upsertDocumentReviewCommentForSync(comment: DocumentReviewCommentSyncRecord): DocumentReviewCommentSyncRecord;
+    upsertDocumentReviewCommentForSync(comment: DocumentReviewCommentSyncRecord, options?: {
+        allowAuthoritativeThreadReconciliation?: boolean;
+    }): DocumentReviewCommentSyncRecord;
     upsertAnnotatedAttachmentSessionForSync(session: AnnotatedAttachmentSessionRecord): AnnotatedAttachmentSessionRecord;
     upsertTaskEventForSync(event: TaskEvent): TaskEvent;
     upsertEntityEventForSync(event: EntityEvent, options?: {
@@ -1633,6 +1645,9 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     setSystemRole(userId: string, role: SystemRole): boolean;
     setUserDisabledGlobal(userId: string, disabled: boolean): boolean;
     setUserBetaAccessGlobal(userId: string, enabled: boolean): boolean;
+    hasUserFeatureGrant(userId: string, featureKey: unknown): boolean;
+    listUserFeatureGrants(userId: string): InternalUserFeatureKey[];
+    setUserFeatureGrant(userId: string, featureKey: unknown, enabled: boolean, updatedBy?: string | null): boolean;
     markUserEmailVerified(userId: string): {
         emailVerifiedAt: string;
     } | null;
@@ -1774,7 +1789,9 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         includeDeleted?: boolean;
     }): AnnotatedAttachmentSessionRecord[];
     upsertDocumentReviewSessionForSync(session: DocumentReviewSessionRecord): DocumentReviewSessionRecord;
-    upsertDocumentReviewCommentForSync(comment: Omit<DocumentReviewCommentSyncRecord, 'parentCommentId' | 'threadStatus' | 'threadStatusUpdatedAt' | 'resolvedAt' | 'resolvedByActorId'> & Partial<Pick<DocumentReviewCommentSyncRecord, 'parentCommentId' | 'threadStatus' | 'threadStatusUpdatedAt' | 'resolvedAt' | 'resolvedByActorId'>>): DocumentReviewCommentSyncRecord;
+    upsertDocumentReviewCommentForSync(comment: Omit<DocumentReviewCommentSyncRecord, 'parentCommentId' | 'threadStatus' | 'threadStatusUpdatedAt' | 'resolvedAt' | 'resolvedByActorId'> & Partial<Pick<DocumentReviewCommentSyncRecord, 'parentCommentId' | 'threadStatus' | 'threadStatusUpdatedAt' | 'resolvedAt' | 'resolvedByActorId'>>, options?: {
+        allowAuthoritativeThreadReconciliation?: boolean;
+    }): DocumentReviewCommentSyncRecord;
     upsertAnnotatedAttachmentSessionForSync(session: AnnotatedAttachmentSessionRecord): AnnotatedAttachmentSessionRecord;
     upsertTaskEventForSync(event: TaskEvent): TaskEvent;
     upsertEntityEventForSync(event: EntityEvent, options?: {
@@ -2208,6 +2225,15 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         tokenId: string;
         createdByIp?: string | null;
     }): McpAccessTokenIssueResult;
+    updateMcpAccessTokenToolProfile(input: {
+        actorUserId: string;
+        workspaceId: string;
+        tokenId: string;
+        toolProfile: unknown;
+    }): {
+        record: McpAccessTokenRecord;
+        previousToolProfile: McpCloudToolProfile;
+    };
     authenticateMcpAccessToken(token: string, workspaceId?: string): McpAccessTokenAuthResult | null;
     inspectMcpAccessToken(token: string): McpAccessTokenInspectionResult | null;
     recordMcpAccessTokenUsage(input: {
@@ -2220,6 +2246,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         provider: McpOAuthProvider | string;
         clientName: string;
         redirectUris: unknown;
+        applicationType?: unknown;
         productClientId?: string | null;
     }): McpOAuthClientRecord;
     getMcpOAuthClient(clientId: string, provider?: McpOAuthProvider | string | null): McpOAuthClientRecord | null;
@@ -2253,6 +2280,15 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         workspaceId: string;
         grantId: string;
     }): McpOAuthConnectorGrantRecord;
+    updateMcpOAuthConnectorGrantToolProfile(input: {
+        actorUserId: string;
+        workspaceId: string;
+        grantId: string;
+        toolProfile: unknown;
+    }): {
+        record: McpOAuthConnectorGrantRecord;
+        previousToolProfile: McpCloudToolProfile;
+    };
     authenticateMcpOAuthAccessToken(token: string, workspaceId?: string): McpOAuthAccessTokenAuthResult | null;
     bindMcpOAuthConnectorGrantAiProfile(input: {
         grantId: string;
@@ -2426,7 +2462,9 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     notifyDurableWorkflowRuntimeCommitted(workspaceId: string, _executionId: string): void;
     installDurableInitiativeAuthoritativeForSync(initiative: InitiativeItem, workspaceId: string): InitiativeItem;
     installDurableWorkstreamAuthoritativeForSync(workstream: WorkstreamItem, workspaceId: string): WorkstreamItem;
-    installDurableTaskCreateAuthoritativeForSync(task: TaskItem, workspaceId: string): TaskItem;
+    installDurableTaskCreateAuthoritativeForSync(task: TaskItem, workspaceId: string, options?: {
+        preserveDeletedSuccessor?: boolean;
+    }): TaskItem;
     installWorkspaceSyncV3TaskRootAuthoritativeForSync(task: TaskItem, workspaceId: string): TaskItem;
     bulkCreateTasks(tasks: Array<Partial<TaskItem>>, options?: {
         atomic?: boolean;
@@ -2467,8 +2505,10 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     notifyDurableTaskMetadataCommitted(workspaceId: string, taskId: string): void;
     addComment(id: string, text: string, author: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        emitRealtime?: boolean;
         actorRef?: string;
         skipTaskEvents?: boolean;
+        commentId?: string;
     }): TaskItem | null;
     private addPlanningEntityComment;
     addInitiativeComment(id: string, text: string, author: string, workspaceId?: string, options?: {

package/dist/core/Taskforce.js

@@ -27,6 +27,7 @@ import { listTaskAttachmentLinksForDurableSync as listTaskAttachmentLinksForDura
 import { EntityEventIdentityCollisionError, addEntityEventService, addTaskEventService, buildEntityActivityService, buildTaskActivityService, getEntityEventForSyncService, getTaskEventForSyncService, listEntityEventsInternalService, listWorkspaceEntityEventsForSyncService, listTaskEventsInternalService, listWorkspaceTaskEventsForSyncService, replaceEntityEventsService, replaceTaskCommentsService, replaceTaskEventsService, upsertEntityEventForSyncService, deleteEntityEventForSyncService, upsertTaskEventForSyncService, } from './TaskActivityService.js';
 import { addDeletedTaskRecordService, getDeletedTaskService, listDeletedTasksService, listDeletedTasksReadOnlyService, mapDeletedTaskRowService, normalizeTaskSnapshotForRestoreService, normalizeDeletedTaskRestoreLifecycleService, purgeExpiredDeletedTasksService, } from './DeletedTaskLifecycleService.js';
 import { DELETED_TASK_RETENTION_DAYS } from '../shared/deletedTaskRetention.js';
+import { INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY, isSupportedInternalUserFeatureKey, } from '../shared/userFeatureGrants.js';
 import { applyWorkspaceSyncSnapshotService, claimPushIdempotencyService, completePushIdempotencyClaimService, deleteDocumentWatermarkService, deleteDocumentWatermarkStrictService, getDocumentWatermarkService, listTasksForSyncService, listWorkspaceSyncDeletesSinceService, readPushIdempotencyService, releasePushIdempotencyClaimService, renewPushIdempotencyClaimService, recordSyncEventDurablyService, recordSyncEventService, upsertDocumentWatermarkService, upsertDocumentWatermarkStrictService, writePushIdempotencyService, } from './SyncReconciliationService.js';
 import { getGlobalSettingsService, hasPersistedGlobalSettingsService, readGlobalConfigService, updateGlobalSettingsService, writeGlobalConfigService, } from './GlobalSettingsService.js';
 import { getWorkspaceTaxonomyStateService, upsertWorkspaceTaxonomyStateService, } from './TaxonomySettingsService.js';
@@ -62,7 +63,7 @@ import { getCanonicalDocumentName } from '../utils/documentNames.js';
 import { isPathInsideRoot, resolveStorageKeyPathInsideRoot } from '../utils/pathSafety.js';
 import { DEFAULT_TASKFORCE_THEME } from '../utils/theme.js';
 import { normalizeTaskSearchQuery } from '../utils/taskSearch.js';
-import { ensureAssigneeTaskSchema, ensureAnnotatedAttachmentSessionsSchema, ensureAuthIdentitySchema, backfillPlanningAttachmentAssetIdentities, ensureBillingSchema, ensureDocumentReviewSessionsSchema, ensureDocumentReferenceSchema, ensureEntitlementsSchema, ensurePlanningReferenceSchema, ensureScheduleTaskSchema, ensureWorkstreamTaskOrderSchema, ensureTaskAssetsSchema, ensureTaskApproachRemoved, ensureAgentRolesSchema, ensureTaskforceAgentsSchema, ensureTaskforceAgentSkillsSchema, ensureTaskReferenceSchema, ensureTenantSchema, ensureWorkflowSchema, ensureWorkspaceAssetsSchema, ensureWorkspaceSchema, ensureLocalSyncCoordinatorSchema, ensureWorkspaceSyncDurabilitySchema } from '../migrations/taskSchemaMigrations.js';
+import { ensureAssigneeTaskSchema, ensureAnnotatedAttachmentSessionsSchema, ensureAuthIdentitySchema, backfillPlanningAttachmentAssetIdentities, ensureBillingSchema, ensureDocumentReviewSessionsSchema, ensureDocumentReferenceSchema, ensureEntitlementsSchema, ensurePlanningReferenceSchema, ensureScheduleTaskSchema, ensureWorkstreamTaskOrderSchema, ensureTaskAssetsSchema, ensureTaskApproachRemoved, ensureAgentRolesSchema, ensureGitHubReviewEvidenceInstallationBindingsSchema, ensureExecutorPhaseAApprovalReceiptsSchema, ensureExecutorPhaseARunAuthorizationsSchema, ensureModelProviderConnectionsSchema, ensureTaskforceAgentConnectionBindingsSchema, ensureTaskforceAgentsSchema, ensureTaskforceAgentSkillsSchema, ensureTaskReferenceSchema, ensureTenantSchema, ensureWorkflowSchema, ensureWorkspaceAssetsSchema, ensureWorkspaceSchema, ensureLocalSyncCoordinatorSchema, ensureWorkspaceSyncDurabilitySchema } from '../migrations/taskSchemaMigrations.js';
 import { repairTaskUpdatedAtOnlySyncDrift } from '../migrations/taskUpdatedAtSyncDriftMigration.js';
 export class TaskforceRuleError extends Error {
     statusCode;
@@ -1457,7 +1458,14 @@ export class TaskforceCore {
             ensureDocumentReferenceSchema(this.db);
             ensureDocumentReviewSessionsSchema(this.db);
             ensureAnnotatedAttachmentSessionsSchema(this.db);
+            ensureModelProviderConnectionsSchema(this.db);
             ensureTaskforceAgentsSchema(this.db);
+            ensureTaskforceAgentConnectionBindingsSchema(this.db);
+            ensureGitHubReviewEvidenceInstallationBindingsSchema(this.db);
+            if (this.runtimeMode === 'cloud') {
+                ensureExecutorPhaseAApprovalReceiptsSchema(this.db);
+                ensureExecutorPhaseARunAuthorizationsSchema(this.db);
+            }
             ensureAgentRolesSchema(this.db);
             ensureTaskforceAgentSkillsSchema(this.db);
             ensureWorkflowSchema(this.db);
@@ -1969,6 +1977,18 @@ export class TaskforceCore {
                 PRIMARY KEY (tenant_id, user_id, prefs_key)
             );
 
+            CREATE TABLE IF NOT EXISTS user_feature_grants (
+                tenant_id TEXT NOT NULL DEFAULT 'default',
+                user_id TEXT NOT NULL,
+                feature_key TEXT NOT NULL,
+                enabled INTEGER NOT NULL DEFAULT 0,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                updated_by TEXT,
+                PRIMARY KEY (tenant_id, user_id, feature_key),
+                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+            );
+
             CREATE TABLE IF NOT EXISTS admin_audit_logs (
                 id TEXT PRIMARY KEY,
                 tenant_id TEXT NOT NULL DEFAULT 'default',
@@ -2013,6 +2033,7 @@ export class TaskforceCore {
                 provider TEXT NOT NULL,
                 client_name TEXT NOT NULL,
                 redirect_uris_json TEXT NOT NULL,
+                application_type TEXT NOT NULL DEFAULT 'web',
                 product_client_id TEXT,
                 status TEXT NOT NULL DEFAULT 'active',
                 created_at TEXT NOT NULL,
@@ -2047,6 +2068,7 @@ export class TaskforceCore {
                 user_id TEXT NOT NULL,
                 workspace_id TEXT NOT NULL DEFAULT 'default',
                 scopes_json TEXT NOT NULL,
+                tool_profile TEXT NOT NULL DEFAULT 'default',
                 token_prefix TEXT NOT NULL,
                 token_hash TEXT NOT NULL,
                 status TEXT NOT NULL DEFAULT 'active',
@@ -2188,6 +2210,7 @@ export class TaskforceCore {
             CREATE INDEX IF NOT EXISTS idx_ui_state_workspace_key ON ui_state(workspace_id, state_key);
             CREATE INDEX IF NOT EXISTS idx_workspace_settings_workspace_key ON workspace_settings(workspace_id, settings_key);
             CREATE INDEX IF NOT EXISTS idx_user_preferences_user_key ON user_preferences(user_id, prefs_key);
+            CREATE INDEX IF NOT EXISTS idx_user_feature_grants_feature_enabled ON user_feature_grants(tenant_id, feature_key, enabled);
             CREATE INDEX IF NOT EXISTS idx_admin_audit_logs_tenant_created ON admin_audit_logs(tenant_id, created_at);
             CREATE INDEX IF NOT EXISTS idx_admin_audit_logs_workspace_created ON admin_audit_logs(workspace_id, created_at);
             CREATE INDEX IF NOT EXISTS idx_task_events_task_created ON task_events(tenant_id, workspace_id, task_id, created_at);
@@ -2363,6 +2386,9 @@ export class TaskforceCore {
             if (!mcpOauthClientColumns.some((c) => c.name === 'product_client_id')) {
                 this.db.exec(`ALTER TABLE mcp_oauth_clients ADD COLUMN product_client_id TEXT`);
             }
+            if (!mcpOauthClientColumns.some((c) => c.name === 'application_type')) {
+                this.db.exec(`ALTER TABLE mcp_oauth_clients ADD COLUMN application_type TEXT NOT NULL DEFAULT 'web'`);
+            }
             const mcpOauthGrantColumns = this.db.prepare(`PRAGMA table_info(mcp_oauth_connector_grants)`).all();
             if (!mcpOauthGrantColumns.some((c) => c.name === 'product_client_id')) {
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN product_client_id TEXT`);
@@ -2376,14 +2402,19 @@ export class TaskforceCore {
             if (!mcpOauthGrantColumns.some((c) => c.name === 'ai_profile_name')) {
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN ai_profile_name TEXT`);
             }
+            if (!mcpOauthGrantColumns.some((c) => c.name === 'tool_profile')) {
+                this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN tool_profile TEXT NOT NULL DEFAULT 'default'`);
+            }
         }
         else {
             try {
                 this.db.exec(`ALTER TABLE mcp_oauth_clients ADD COLUMN IF NOT EXISTS product_client_id TEXT`);
+                this.db.exec(`ALTER TABLE mcp_oauth_clients ADD COLUMN IF NOT EXISTS application_type TEXT NOT NULL DEFAULT 'web'`);
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN IF NOT EXISTS product_client_id TEXT`);
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN IF NOT EXISTS ai_profile_id TEXT`);
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN IF NOT EXISTS ai_profile_token TEXT`);
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN IF NOT EXISTS ai_profile_name TEXT`);
+                this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN IF NOT EXISTS tool_profile TEXT NOT NULL DEFAULT 'default'`);
             }
             catch {
                 // Best-effort schema repair for existing deployments.
@@ -6956,7 +6987,7 @@ export class TaskforceCore {
                 OR LOWER(COALESCE(u.system_role, 'user')) LIKE ?
               )`
             : '';
-        const params = [this.tenantId];
+        const params = [INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY, this.tenantId];
         if (query) {
             params.push(queryPattern, queryPattern, queryPattern, queryPattern, queryPattern, queryPattern, queryPattern);
         }
@@ -6969,6 +7000,14 @@ export class TaskforceCore {
                 COALESCE(u.system_role, 'user') AS system_role,
                 COALESCE(u.beta_access, 1) AS beta_access,
                 COALESCE(u.is_disabled, 0) AS is_disabled,
+                CASE WHEN EXISTS (
+                    SELECT 1
+                    FROM user_feature_grants g
+                    WHERE g.tenant_id = u.tenant_id
+                      AND g.user_id = u.id
+                      AND g.feature_key = ?
+                      AND g.enabled = 1
+                ) THEN 1 ELSE 0 END AS subscription_model_access,
                 u.created_at,
                 u.updated_at,
                 u.email_verified_at,
@@ -7000,6 +7039,9 @@ export class TaskforceCore {
             systemRole: this.normalizeSystemRole(row.system_role, 'user'),
             betaAccess: row.beta_access === undefined || row.beta_access === null ? true : Boolean(row.beta_access),
             disabled: Boolean(row.is_disabled),
+            internalFeatureGrants: Boolean(row.subscription_model_access)
+                ? [INTERNAL_SUBSCRIPTION_MODEL_FEATURE_KEY]
+                : [],
             planId: row.plan_id ? String(row.plan_id) : null,
             planName: row.plan_name ? String(row.plan_name) : null,
             planVersionId: row.plan_version_id ? String(row.plan_version_id) : null,
@@ -7073,6 +7115,53 @@ export class TaskforceCore {
         `).run(enabled ? 1 : 0, new Date().toISOString(), this.tenantId, normalizedUserId);
         return Number(result?.changes || 0) > 0;
     }
+    hasUserFeatureGrant(userId, featureKey) {
+        const normalizedUserId = String(userId || '').trim();
+        if (!normalizedUserId || !isSupportedInternalUserFeatureKey(featureKey))
+            return false;
+        const row = this.db.prepare(`
+            SELECT enabled
+            FROM user_feature_grants
+            WHERE tenant_id = ? AND user_id = ? AND feature_key = ?
+            LIMIT 1
+        `).get(this.tenantId, normalizedUserId, featureKey);
+        return Boolean(row?.enabled);
+    }
+    listUserFeatureGrants(userId) {
+        const normalizedUserId = String(userId || '').trim();
+        if (!normalizedUserId)
+            return [];
+        const rows = this.db.prepare(`
+            SELECT feature_key
+            FROM user_feature_grants
+            WHERE tenant_id = ? AND user_id = ? AND enabled = 1
+            ORDER BY feature_key
+        `).all(this.tenantId, normalizedUserId);
+        return rows
+            .map((row) => row.feature_key)
+            .filter(isSupportedInternalUserFeatureKey);
+    }
+    setUserFeatureGrant(userId, featureKey, enabled, updatedBy) {
+        const normalizedUserId = String(userId || '').trim();
+        if (!normalizedUserId || !isSupportedInternalUserFeatureKey(featureKey))
+            return false;
+        const user = this.db.prepare(`
+            SELECT id FROM users WHERE tenant_id = ? AND id = ? LIMIT 1
+        `).get(this.tenantId, normalizedUserId);
+        if (!user?.id)
+            return false;
+        const now = new Date().toISOString();
+        this.db.prepare(`
+            INSERT INTO user_feature_grants (
+                tenant_id, user_id, feature_key, enabled, created_at, updated_at, updated_by
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (tenant_id, user_id, feature_key) DO UPDATE SET
+                enabled = excluded.enabled,
+                updated_at = excluded.updated_at,
+                updated_by = excluded.updated_by
+        `).run(this.tenantId, normalizedUserId, featureKey, enabled ? 1 : 0, now, now, String(updatedBy || '').trim() || null);
+        return true;
+    }
     markUserEmailVerified(userId) {
         const normalizedUserId = String(userId || '').trim();
         if (!normalizedUserId)
@@ -7179,6 +7268,14 @@ export class TaskforceCore {
             if (hasCommercialBillingState) {
                 throw new TaskforceRuleError('Cannot purge a user with active commercial billing state', 409, 'SYSTEM_USER_PURGE_BLOCKED_BILLING_STATE');
             }
+            const modelConnectionCount = Number(this.db.prepare(`
+                SELECT COUNT(*) AS count
+                FROM model_provider_connections
+                WHERE tenant_id = ? AND owner_user_id = ?
+            `).get(this.tenantId, targetUserId)?.count || 0);
+            if (modelConnectionCount > 0) {
+                throw new TaskforceRuleError('Disconnect and clean up the user model connections before purging this account', 409, 'SYSTEM_USER_PURGE_BLOCKED_MODEL_CONNECTIONS');
+            }
             const now = new Date().toISOString();
             const runCount = (sql, ...params) => Number(this.db.prepare(sql).run(...params)?.changes || 0);
             const workspaceIds = this.db.prepare(`
@@ -7278,6 +7375,11 @@ export class TaskforceCore {
                 WHERE tenant_id = ?
                   AND user_id = ?
             `, this.tenantId, targetUserId);
+            const deletedUserFeatureGrantCount = runCount(`
+                DELETE FROM user_feature_grants
+                WHERE tenant_id = ?
+                  AND user_id = ?
+            `, this.tenantId, targetUserId);
             const deletedUserBillingCount = runCount(`
                 DELETE FROM user_billing
                 WHERE tenant_id = ?
@@ -7305,6 +7407,7 @@ export class TaskforceCore {
                 deletedMcpOauthConnectorGrantCount,
                 deletedUiStateCount,
                 deletedUserPreferenceCount,
+                deletedUserFeatureGrantCount,
                 deletedEntitlementCount,
                 deletedUserBillingCount,
                 deletedUserCount
@@ -7651,7 +7754,7 @@ export class TaskforceCore {
             deletedAt: session.deletedAt,
         });
     }
-    upsertDocumentReviewCommentForSync(comment) {
+    upsertDocumentReviewCommentForSync(comment, options) {
         const deps = this.getDocumentReviewServiceDeps();
         return deps.commentStore.upsertForSync({
             id: comment.id,
@@ -7671,7 +7774,7 @@ export class TaskforceCore {
             createdAt: comment.createdAt,
             updatedAt: comment.updatedAt,
             deletedAt: comment.deletedAt,
-        });
+        }, options);
     }
     upsertAnnotatedAttachmentSessionForSync(session) {
         const deps = this.getAnnotatedAttachmentServiceDeps();
@@ -8743,6 +8846,9 @@ export class TaskforceCore {
     regenerateMcpAccessToken(input) {
         return this.mcpTokenService.regenerateMcpAccessToken(input);
     }
+    updateMcpAccessTokenToolProfile(input) {
+        return this.mcpTokenService.updateMcpAccessTokenToolProfile(input);
+    }
     authenticateMcpAccessToken(token, workspaceId) {
         return this.mcpTokenService.authenticateMcpAccessToken(token, workspaceId);
     }
@@ -8770,6 +8876,9 @@ export class TaskforceCore {
     revokeMcpOAuthConnectorGrant(input) {
         return this.mcpTokenService.revokeMcpOAuthConnectorGrant(input);
     }
+    updateMcpOAuthConnectorGrantToolProfile(input) {
+        return this.mcpTokenService.updateMcpOAuthConnectorGrantToolProfile(input);
+    }
     authenticateMcpOAuthAccessToken(token, workspaceId) {
         return this.mcpTokenService.authenticateMcpOAuthAccessToken(token, workspaceId);
     }
@@ -9871,7 +9980,7 @@ export class TaskforceCore {
             return this.getWorkstream(workstreamId, normalizedWorkspaceId) || updated;
         })();
     }
-    installDurableTaskCreateAuthoritativeForSync(task, workspaceId) {
+    installDurableTaskCreateAuthoritativeForSync(task, workspaceId, options) {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const taskId = String(task?.id || '').trim();
         const createdAt = String(task?.createdAt || '').trim();
@@ -9889,6 +9998,31 @@ export class TaskforceCore {
         return this.db.transaction(() => {
             const existing = this.getTask(taskId, normalizedWorkspaceId);
             if (!existing) {
+                const deleted = options?.preserveDeletedSuccessor
+                    ? this.getDeletedTask(taskId, normalizedWorkspaceId)
+                    : null;
+                if (deleted) {
+                    this.relocateTaskReferenceConflict(normalizedWorkspaceId, referenceNumber, taskId, updatedAt);
+                    if (this.reserveTaskReferenceNumber(normalizedWorkspaceId, referenceNumber, taskId) !== referenceNumber) {
+                        throw new TaskforceRuleError('Authoritative task reference is already in use.', 409, 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID');
+                    }
+                    const authoritativeSnapshot = {
+                        ...deleted.taskSnapshot,
+                        referenceNumber,
+                        localReferenceNumber: null,
+                        referenceLabel: deriveTaskReferenceLabel({ referenceNumber, localReferenceNumber: null }),
+                        createdAt,
+                        createdBy: task.createdBy,
+                    };
+                    const updated = this.db.prepare(`
+                        UPDATE deleted_tasks SET task_snapshot_json = ?
+                        WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?
+                    `).run(JSON.stringify(authoritativeSnapshot), this.tenantId, normalizedWorkspaceId, taskId);
+                    if (Number(updated.changes || 0) !== 1) {
+                        throw new TaskforceRuleError('Captured deleted task history is missing.', 409, 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID');
+                    }
+                    return this.getDeletedTask(taskId, normalizedWorkspaceId).taskSnapshot;
+                }
                 throw new TaskforceRuleError('Task not found.', 404, 'TASK_NOT_FOUND');
             }
             const mutableCreateFields = [
@@ -10653,8 +10787,25 @@ export class TaskforceCore {
             return null;
         const submittedAuthor = String(author || '').trim() || 'user';
         const normalizedAuthor = this.normalizeCommentAuthor(author, normalizedWorkspaceId);
+        const explicitCommentId = String(options?.commentId || '').trim();
+        if (explicitCommentId) {
+            const persisted = this.db.prepare(`
+                SELECT task_id, text, author, submitted_author
+                FROM comments
+                WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+            `).get(this.tenantId, normalizedWorkspaceId, explicitCommentId);
+            if (persisted) {
+                if (persisted.task_id !== id
+                    || persisted.text !== text
+                    || persisted.author !== normalizedAuthor
+                    || String(persisted.submitted_author || persisted.author) !== submittedAuthor) {
+                    throw new TaskforceRuleError('Task comment identity is assigned to different content.', 409, 'TASK_COMMENT_IDENTITY_CONFLICT');
+                }
+                return this.getTask(id, normalizedWorkspaceId);
+            }
+        }
         const comment = {
-            id: this.generateEntityId('comment'),
+            id: explicitCommentId || this.generateEntityId('comment'),
             author: normalizedAuthor,
             submittedAuthor,
             text,
@@ -10697,7 +10848,7 @@ export class TaskforceCore {
         if (options?.persistBackup !== false)
             this.persistBackup();
         const updated = this.getTask(id, normalizedWorkspaceId);
-        if (updated) {
+        if (updated && options?.emitRealtime !== false) {
             this.emitRealtimeMutation({
                 workspaceId: normalizedWorkspaceId,
                 entityType: 'task',