@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/core/Taskforce.d.ts

@@ -1,4 +1,13 @@
 import type { DatabaseAdapter, DatabaseProvider } from '../storage/databaseAdapter.js';
+import { WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
+import { type SyncEventInput } from './SyncReconciliationService.js';
+import { type FirstClassTaxonomyDisplayLabels, type WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
+import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+export type { WorkspaceDeletedAssetRecord, WorkspaceDeleteSummary } from './types.js';
+import type { GlobalTaskforceSettings, UserGlobalSyncSettings, WorkspaceDeleteSummary } from './types.js';
+import type { AnnotatedAttachmentAnnotation, AnnotatedAttachmentPayload, AnnotatedAttachmentSession, AnnotatedAttachmentSessionRecord } from '../annotatedAttachments/types.js';
+import type { DocumentReviewAnchor, DocumentReviewCommentSyncRecord, DocumentReviewSession, DocumentReviewSessionRecord, DocumentReviewSessionStatus } from '../documentReviews/types.js';
+import { type TaskforceTheme } from '../utils/theme.js';
 /**
  * Taskforce Core Logic
  *
@@ -8,13 +17,76 @@ import type { DatabaseAdapter, DatabaseProvider } from '../storage/databaseAdapt
 export interface Comment {
     id: string;
     author: string;
+    submittedAuthor?: string;
     text: string;
     timestamp: string;
+    actor?: TaskActor | null;
+}
+export interface TaskEventChange {
+    from: unknown;
+    to: unknown;
+}
+export interface TaskEventDetails {
+    changes?: Record<string, TaskEventChange>;
+    [key: string]: unknown;
+}
+export interface TaskEvent {
+    id: string;
+    taskId: string;
+    workspaceId: string;
+    action: string;
+    actor: string;
+    actorType: 'human' | 'ai' | 'system';
+    createdAt: string;
+    details?: TaskEventDetails;
+    actorProfile?: TaskActor | null;
+}
+export interface CommentActivityItem {
+    id: string;
+    type: 'comment';
+    timestamp: string;
+    comment: Comment;
+}
+export interface AuditActivityItem {
+    id: string;
+    type: 'event';
+    timestamp: string;
+    event: TaskEvent;
+}
+export type TaskActivityItem = CommentActivityItem | AuditActivityItem;
+export type DeletedTaskSource = 'ui' | 'mcp' | 'sync' | 'workspace-delete' | 'system';
+export interface DeletedTaskDetails {
+    reason?: string | null;
+    [key: string]: unknown;
+}
+export interface DeletedTaskRecord {
+    id: string;
+    taskId: string;
+    workspaceId: string;
+    deletedAt: string;
+    actor: string;
+    actorType: 'human' | 'ai' | 'system';
+    source: DeletedTaskSource;
+    details?: DeletedTaskDetails;
+    taskSnapshot: TaskItem;
+    actorProfile?: TaskActor | null;
 }
 export type TaskStatus = 'task' | 'on-hold' | 'in-progress' | 'review' | 'done' | 'cancelled';
-export type TaskAssignee = 'unassigned' | 'agent' | 'user';
+export type TaskAssignee = string;
+export interface TaskActor {
+    id: string;
+    kind: 'human' | 'ai';
+    label: string;
+    username: string;
+    icon: string;
+    color: string;
+    isNamed: boolean;
+    meta?: Record<string, unknown>;
+}
 export interface TaskItem {
     id: string;
+    referenceNumber?: number | null;
+    referenceLabel?: string;
     title: string;
     description: string | null;
     category: string;
@@ -26,40 +98,84 @@ export interface TaskItem {
     createdAt: string;
     updatedAt?: string;
     completedAt?: string | null;
-    /** @deprecated */
+    /** @deprecated DO NOT USE. Use status='in-progress'. Safe to remove after v0.4.x migration gate. */
     inProgress?: boolean;
-    /** @deprecated */
+    /** @deprecated DO NOT USE. Use status='review'. Safe to remove after v0.4.x migration gate. */
     readyForReview?: boolean;
     comments?: Comment[];
+    activity?: TaskActivityItem[];
+    taskEvents?: TaskEvent[];
     attachments?: Array<string | {
         path: string;
         fsPath?: string;
         caption?: string;
         timestamp?: string;
     }>;
-    /** @deprecated Legacy input compatibility only. Use attachments. */
-    screenshots?: Array<string | {
-        path: string;
-        fsPath?: string;
-        caption?: string;
-        timestamp?: string;
-    }>;
-    specialists?: string[];
-    /** @deprecated */
+    /** @deprecated Use status='done'. Safe to remove after v0.4.x migration gate. */
     completed?: boolean;
-    /** @deprecated */
+    /** @deprecated Use status='cancelled'. Safe to remove after v0.4.x migration gate. */
     cancelled?: boolean;
     taxonomies?: Record<string, string | string[]>;
     createdBy?: string;
+    createdByActor?: TaskActor | null;
     assignee?: TaskAssignee;
+    assigneeActor?: TaskActor | null;
     canceledReason?: string;
     isArchived?: boolean;
     scheduledDate?: string | null;
     dueDate?: string | null;
     scheduledWeekKey?: string | null;
     orderInDay?: number | null;
-    parentTaskId?: string | null;
-    childDisplayOrder?: number | null;
+    workstreamId?: string | null;
+    checklistItems?: ChecklistItem[];
+}
+export interface InitiativeItem {
+    id: string;
+    referenceNumber?: number | null;
+    referenceLabel?: string;
+    title: string;
+    description: string | null;
+    ownerId?: string | null;
+    comments?: Comment[];
+    attachments?: Array<string | {
+        path: string;
+        fsPath?: string;
+        caption?: string;
+        timestamp?: string;
+    }>;
+    createdAt: string;
+    updatedAt?: string;
+    order?: number | null;
+    isArchived?: boolean;
+}
+export interface WorkstreamItem {
+    id: string;
+    referenceNumber?: number | null;
+    referenceLabel?: string;
+    initiativeId?: string | null;
+    title: string;
+    description: string | null;
+    ownerId?: string | null;
+    comments?: Comment[];
+    attachments?: Array<string | {
+        path: string;
+        fsPath?: string;
+        caption?: string;
+        timestamp?: string;
+    }>;
+    createdAt: string;
+    updatedAt?: string;
+    order?: number | null;
+    isArchived?: boolean;
+}
+export interface ChecklistItem {
+    id: string;
+    taskId: string;
+    title: string;
+    isCompleted: boolean;
+    order: number;
+    createdAt: string;
+    updatedAt?: string;
 }
 export interface TaskWarning {
     code: string;
@@ -112,6 +228,7 @@ export declare class TaskforceRuleError extends Error {
 export interface CategoryConfig {
     value: string;
     label: string;
+    aliases?: string[];
     path?: string;
     paths?: string[];
     specialistFile?: string;
@@ -123,6 +240,7 @@ export interface TaskforceConfig {
     projectRoot: string;
     storagePath?: string;
     tenantId?: string;
+    runtimeMode?: RuntimeMode;
     database?: {
         provider?: DatabaseProvider;
         connectionString?: string;
@@ -135,6 +253,10 @@ export interface TaskFile {
         types?: Array<{
             value: string;
             label: string;
+            color?: string;
+            icon?: string;
+            aliases?: string[];
+            status?: 'active' | 'retired';
         }>;
         priorities?: Array<{
             value: number;
@@ -154,11 +276,13 @@ export interface TaskFile {
             color?: string;
             icon?: string;
         }>;
-        theme?: 'dark' | 'light' | 'midnight';
+        theme?: TaskforceTheme;
         shortcut?: string;
         jsonBackupEnabled?: boolean;
+        manualComplexityEnabled?: boolean;
+        checklistDropdownEnabled?: boolean;
+        showTaskCardStatusLabel?: boolean;
         taxonomies?: any[];
-        assigneeFilterEnabled?: boolean;
     };
 }
 export interface ArchiveFile {
@@ -216,64 +340,21 @@ export interface InitiativeTemplate {
         rollbackPlan: string[];
     };
     milestones: InitiativeTemplateMilestone[];
-    defaultSpecialists?: string[];
-}
-interface GlobalTaskforceSettings {
-    theme?: 'dark' | 'light' | 'midnight';
-    shortcut?: string;
-    jsonBackupEnabled?: boolean;
-    realtimeSyncEnabled?: boolean;
-    schedulePreferences?: {
-        showWeekends?: boolean;
-        isCalendarSidebarOpen?: boolean;
-        weekStartsOn?: 'sunday' | 'monday';
-        dailyCapacity?: {
-            monday?: number;
-            tuesday?: number;
-            wednesday?: number;
-            thursday?: number;
-            friday?: number;
-            saturday?: number;
-            sunday?: number;
-        };
-    };
-    email?: {
-        provider?: 'console' | 'resend' | 'google-workspace';
-        from?: string;
-        replyTo?: string;
-        providerApiKey?: string;
-    };
-    auth?: {
-        allowSelfRegistration?: boolean;
-        requireVerifiedEmail?: boolean;
-        defaultNewUserBetaAccess?: boolean;
-        authRateLimitEnabled?: boolean;
-        authRateLimitMaxRequests?: number;
-        authRateLimitWindowMs?: number;
-    };
-    setup?: {
-        mode?: 'core' | 'operations';
-        forceSetup?: boolean;
-        forceGlobalSetup?: boolean;
-        forceWorkspaceSetup?: boolean;
-    };
-    objectStorage?: {
-        keyPrefix?: string;
-        signedUploadTtlSeconds?: number;
-        signedDownloadTtlSeconds?: number;
-    };
 }
-interface UserGlobalSyncSettings {
-    theme?: 'dark' | 'light' | 'midnight';
-    operatingMode?: 'core' | 'operations';
-    localization?: {
-        locale?: string;
-        weekStartsOn?: 'sunday' | 'monday';
-    };
+type WorkspaceSyncSettingsPayload = Record<string, Record<string, unknown>>;
+type SignupMonetizationStrategy = 'auto_assign_default' | 'plan_selection_required';
+interface SignupMonetizationSettings {
+    strategy: SignupMonetizationStrategy;
+    defaultSignupPlanVersionId: string | null;
 }
 type AccessRole = 'owner' | 'admin' | 'member' | 'read-only';
 export type SystemRole = 'system_admin' | 'user';
 type PermissionMode = 'read-only' | 'read-write';
+export type McpAccessTokenScope = 'tasks:read' | 'tasks:write' | 'workspace:read';
+type McpAccessTokenStatus = 'active' | 'revoked' | 'expired';
+export type McpOAuthProvider = 'chatgpt' | 'claude';
+type McpOAuthClientStatus = 'active' | 'revoked';
+type McpOAuthGrantStatus = 'active' | 'revoked';
 interface UserAccessRecord {
     userId: string;
     workspaceId: string;
@@ -285,6 +366,7 @@ interface UserAccessRecord {
 interface UserIdentityRecord {
     userId: string;
     email: string;
+    displayName?: string | null;
     systemRole?: SystemRole;
     betaAccess?: boolean;
 }
@@ -301,6 +383,45 @@ interface WorkspaceUserRecord {
     updatedAt?: string | null;
     emailVerifiedAt?: string | null;
 }
+export interface AiProfileRecord {
+    id: string;
+    workspaceId: string;
+    profileToken: string;
+    name: string;
+    username: string;
+    icon: string;
+    color: string;
+    description?: string | null;
+    role?: string | null;
+    provider?: string | null;
+    model?: string | null;
+    surfaceType?: AiProfileSurfaceType | null;
+    providerMetadata?: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+    lastActiveAt?: string | null;
+}
+export interface ResolveAiProfileInput {
+    workspaceId: string;
+    name: string;
+    icon?: string;
+    color?: string;
+    description?: string | null;
+    role?: string | null;
+    provider?: string | null;
+    model?: string | null;
+    surfaceType?: AiProfileSurfaceType | null;
+    profileToken?: string | null;
+    providerMetadata?: Record<string, unknown> | null;
+}
+export interface ResolveAiProfileResult {
+    created: boolean;
+    profile: AiProfileRecord;
+    duplicateWarning?: {
+        existingProfileId: string;
+        message: string;
+    };
+}
 interface SystemUserRecord {
     userId: string;
     email: string;
@@ -308,6 +429,10 @@ interface SystemUserRecord {
     systemRole: SystemRole;
     betaAccess: boolean;
     disabled: boolean;
+    planId?: string | null;
+    planName?: string | null;
+    planVersionId?: string | null;
+    entitlementState?: EntitlementState | null;
     createdAt?: string | null;
     updatedAt?: string | null;
     emailVerifiedAt?: string | null;
@@ -330,18 +455,6 @@ export interface UserWorkspaceRecord {
     status: string;
     betaAccess: boolean;
 }
-export interface WorkspaceDeletedAssetRecord {
-    path: string;
-    provider: 'local' | 'r2';
-    workspaceId: string;
-}
-export interface WorkspaceDeleteSummary {
-    deletedWorkspaceId: string;
-    deletedTaskIds: string[];
-    deletedDocumentPaths: string[];
-    deletedAssets: WorkspaceDeletedAssetRecord[];
-    counts: Record<string, number>;
-}
 export interface SetupStateSnapshot {
     globalSetupState: SetupState;
     workspaceSetupState: SetupState;
@@ -363,6 +476,16 @@ interface CreateTaskOptions {
     persistBackup?: boolean;
     workspaceId?: string;
     allowClientProvidedId?: boolean;
+    skipRecompute?: boolean;
+    syncUpdatedAt?: string;
+    actorRef?: string;
+    skipTaskEvents?: boolean;
+}
+interface DeleteTaskOptions {
+    persistBackup?: boolean;
+    actorRef?: string;
+    source?: DeletedTaskSource;
+    details?: DeletedTaskDetails;
 }
 interface AdminAuditLogRecord {
     id: string;
@@ -373,6 +496,21 @@ interface AdminAuditLogRecord {
     workspaceId: string;
     details: Record<string, unknown>;
 }
+interface McpAuditLogRecord {
+    id: string;
+    ts: string;
+    workspaceId: string;
+    actorType: 'local' | 'user' | 'token' | 'oauth';
+    actorUserId: string;
+    tokenId: string | null;
+    toolName: string;
+    requestId: string | null;
+    ip: string | null;
+    userAgent: string | null;
+    outcome: 'allow' | 'deny' | null;
+    reasonCode: string | null;
+    details: Record<string, unknown>;
+}
 export type EntitlementState = 'active' | 'trialing' | 'grace' | 'suspended' | 'canceled';
 export type PlanFeatureAccess = 'enabled' | 'disabled' | 'limited';
 export interface PlanFeatureSnapshot {
@@ -380,12 +518,21 @@ export interface PlanFeatureSnapshot {
     access: PlanFeatureAccess;
     config: Record<string, unknown>;
 }
+export interface PlanFeatureCatalogItem {
+    featureKey: string;
+    label: string;
+    description: string;
+    allowedAccessModes: PlanFeatureAccess[];
+    configTemplate: Record<string, unknown>;
+    dependsOn?: string[];
+}
 export interface PlanVersionSnapshot {
     planVersionId: string;
     planId: string;
     versionNumber: number;
     isDefault: boolean;
     seatLimit: number | null;
+    trialDays: number;
     metadata: Record<string, unknown>;
     features: Record<string, PlanFeatureSnapshot>;
 }
@@ -426,20 +573,200 @@ interface PasswordAuthResult {
     };
     code?: 'INVALID_CREDENTIALS' | 'EMAIL_NOT_VERIFIED';
 }
-export declare class TaskforceCore {
+export interface McpAccessTokenRecord {
+    id: string;
+    workspaceId: string;
+    userId: string;
+    userEmail?: string | null;
+    name: string;
+    scopes: McpAccessTokenScope[];
+    tokenPrefix: string;
+    status: McpAccessTokenStatus;
+    lastUsedAt?: string | null;
+    lastUsedIp?: string | null;
+    lastUsedUserAgent?: string | null;
+    createdByIp?: string | null;
+    expiresAt?: string | null;
+    revokedAt?: string | null;
+    revokedByUserId?: string | null;
+    createdAt: string;
+    updatedAt?: string | null;
+}
+export interface McpAccessTokenListResult {
+    items: McpAccessTokenRecord[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+export interface McpAccessTokenIssueResult {
+    token: string;
+    record: McpAccessTokenRecord;
+}
+export interface McpAccessTokenAuthResult {
+    tokenId: string;
+    workspaceId: string;
+    userId: string;
+    scopes: McpAccessTokenScope[];
+    status: McpAccessTokenStatus;
+}
+export interface McpAccessTokenInspectionResult {
+    tokenId: string;
+    tokenPrefix: string;
+    workspaceId: string;
+    userId: string;
+    name: string;
+    scopes: McpAccessTokenScope[];
+    status: McpAccessTokenStatus;
+}
+export interface McpOAuthClientRecord {
+    id: string;
+    provider: McpOAuthProvider;
+    clientName: string;
+    redirectUris: string[];
+    status: McpOAuthClientStatus;
+    createdAt: string;
+    updatedAt?: string | null;
+}
+export interface McpOAuthConnectorGrantRecord {
+    id: string;
+    provider: McpOAuthProvider;
+    clientId: string;
+    clientName: string;
+    workspaceId: string;
+    userId: string;
+    scopes: McpAccessTokenScope[];
+    tokenPrefix: string;
+    status: McpOAuthGrantStatus;
+    lastUsedAt?: string | null;
+    revokedAt?: string | null;
+    revokedByUserId?: string | null;
+    createdAt: string;
+    updatedAt?: string | null;
+}
+export interface McpOAuthTokenExchangeResult {
+    accessToken: string;
+    tokenType: 'Bearer';
+    scopes: McpAccessTokenScope[];
+    grant: McpOAuthConnectorGrantRecord;
+}
+export interface McpOAuthAccessTokenAuthResult {
+    grantId: string;
+    workspaceId: string;
+    userId: string;
+    clientId: string;
+    provider: McpOAuthProvider;
+    scopes: McpAccessTokenScope[];
+    status: McpOAuthGrantStatus;
+}
+/**
+ * Subset of TaskforceCore methods required by the sync route.
+ * Declared as a separate interface so sync.ts can call these methods with full
+ * type safety instead of relying on `(core as any)` casts.
+ */
+export interface TaskforceSyncCapable {
+    readPushIdempotency(workspaceId: string, idempotencyKey: string): string | null;
+    writePushIdempotency(workspaceId: string, idempotencyKey: string, payload: string): void;
+    getDatabaseAdapter(): DatabaseAdapter;
+    getTenantId(): string;
+    getDocumentWatermark(workspaceId: string, docPath: string): {
+        updatedAt: string;
+        contentHash: string;
+    } | null;
+    upsertDocumentWatermark(workspaceId: string, docPath: string, contentHash: string, updatedAt: string): void;
+    deleteDocumentWatermark(workspaceId: string, docPath: string): void;
+    onRealtimeMutation(listener: (event: RealtimeMutationEvent) => void): () => void;
+    deleteTaskForSync(id: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+    }): boolean;
+    notifyDocumentMetadataMutation(workspaceId: string, entityIds: string[], changeType?: 'upsert' | 'delete'): void;
+    listTasksForSync(workspaceId: string | undefined, cursor: {
+        watermark: string;
+        id: string;
+    } | null, limit: number): Array<{
+        task: any;
+        archived: boolean;
+    }>;
+    listWorkspaceSyncDeletesSince(workspaceId: string | undefined, cursor: {
+        watermark: string;
+        id: string;
+    } | null, limit: number): Array<{
+        taskId: string;
+        deletedAt: string;
+    }>;
+    listWorkspaceSyncDeletes(workspaceId?: string): Array<{
+        taskId: string;
+        deletedAt: string;
+    }>;
+    getTaxonomiesSyncSnapshot(workspaceId?: string): {
+        taxonomies: any[];
+        taxonomyState: WorkspaceTaxonomyState;
+        updatedAt: string;
+    };
+    listInitiatives(workspaceId?: string): InitiativeItem[];
+    listWorkstreams(workspaceId?: string): WorkstreamItem[];
+    listAiProfiles(workspaceId: string): AiProfileRecord[];
+    listWorkspaceUsers(workspaceId: string): WorkspaceUserRecord[];
+    listDocumentReviewSessionsForSync(input: {
+        workspaceId?: string | null;
+        includeDeleted?: boolean;
+    }): DocumentReviewSessionRecord[];
+    listDocumentReviewCommentsForSync(input: {
+        workspaceId?: string | null;
+        includeDeleted?: boolean;
+    }): DocumentReviewCommentSyncRecord[];
+    listAnnotatedAttachmentSessionsForSync(input: {
+        workspaceId?: string | null;
+        includeDeleted?: boolean;
+    }): AnnotatedAttachmentSessionRecord[];
+    upsertAiProfileForSync(profile: AiProfileRecord): AiProfileRecord;
+    replaceWorkspaceUsersForSync(input: {
+        workspaceId: string;
+        users: WorkspaceUserRecord[];
+    }): WorkspaceUserRecord[];
+    upsertInitiativeForSync(initiative: InitiativeItem, workspaceId?: string | null): InitiativeItem;
+    upsertWorkstreamForSync(workstream: WorkstreamItem, workspaceId?: string | null): WorkstreamItem;
+    upsertDocumentReviewSessionForSync(session: DocumentReviewSessionRecord): DocumentReviewSessionRecord;
+    upsertDocumentReviewCommentForSync(comment: DocumentReviewCommentSyncRecord): DocumentReviewCommentSyncRecord;
+    upsertAnnotatedAttachmentSessionForSync(session: AnnotatedAttachmentSessionRecord): AnnotatedAttachmentSessionRecord;
+    deleteDocumentReviewSessionForSync(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        deletedAt?: string | null;
+    }): boolean;
+    deleteDocumentReviewCommentForSync(input: {
+        workspaceId?: string | null;
+        commentId: string;
+        deletedAt?: string | null;
+    }): boolean;
+    deleteAnnotatedAttachmentSessionForSync(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        deletedAt?: string | null;
+    }): boolean;
+    mergeAiProfiles(input: {
+        workspaceId: string;
+        keepId: string;
+        mergeId: string;
+    }): AiProfileRecord;
+    resolveWorkspaceActor(workspaceId: string, actorRef: unknown): TaskActor | null;
+}
+export declare class TaskforceCore implements TaskforceSyncCapable {
     private static readonly DEFAULT_CATEGORY_VALUE;
+    private static readonly DEFAULT_TYPE_VALUE;
     private static readonly DEFAULT_APPROACH_VALUE;
+    private static readonly DELETED_TASK_RETENTION_DAYS;
     private projectRoot;
     private basePath;
+    private runtimeMode;
     private dbPath;
     private configFile;
     private globalSettingsDbPath;
-    private screenshotsDir;
-    private contextFilesDir;
-    private taskDataDir;
     private tenantId;
     private db;
     private globalSettingsDb;
+    private authTokenService;
+    private mcpTokenService;
+    private planEntitlementService;
     private realtimeMutationListeners;
     private readonly realtimeServerEpoch;
     private realtimeMutationSeq;
@@ -447,20 +774,59 @@ export declare class TaskforceCore {
     onRealtimeMutation(listener: (event: RealtimeMutationEvent) => void): () => void;
     private normalizePriorityValue;
     private normalizePriorityDefinitions;
-    private migratePriorityScaleIfNeeded;
-    private migrateOnHoldPriorityToStatusIfNeeded;
-    private healPriorityConfigIfNeeded;
+    private normalizePriorityConfigIfNeeded;
     private estimateComplexity;
     private isAiCreated;
+    private isGenericAiActorReference;
+    private isKnownAiModelName;
+    private isHumanActorReference;
+    private normalizeAiProfileName;
+    private normalizeAiProfileUsername;
+    private normalizeAiProfileIcon;
+    private normalizeAiProfileColor;
+    private formatActorLabel;
+    private buildGenericAiActor;
+    private buildHumanActorFallback;
+    private workspaceUserToActor;
+    private aiProfileRowToRecord;
+    private aiProfileToActor;
+    private canonicalizeActorReference;
+    private normalizeCreatedBy;
     private normalizeCommentAuthor;
+    private normalizeIncomingComments;
+    private parseJsonField;
+    private normalizePlanningAttachments;
+    private replaceTaskComments;
+    private normalizeTaskEventActor;
+    private listTaskEventsInternal;
+    private buildTaskActivity;
+    private addTaskEvent;
+    private replaceTaskEvents;
+    private mapDeletedTaskRow;
+    private pruneDeletedTasks;
+    private normalizeTaskSnapshotForRestore;
+    private addDeletedTaskRecord;
+    private purgeExpiredDeletedTasks;
+    private areTaskEventValuesEqual;
+    private normalizeTaskEventValue;
+    private buildTaskUpdateChanges;
     private normalizeTaxonomyToken;
     private normalizeStatusValue;
     private sanitizeAssignee;
+    private repairTaskAssignee;
     private inferAssigneeFromOwnerHints;
+    private shouldNormalizeEscapedDescription;
+    private normalizeGeneratedDescription;
     private resolveTaxonomyValue;
+    private matchesTaxonomyCandidate;
+    private resolveCustomTaxonomyDefinition;
+    private resolveCustomTaxonomyOptionValue;
+    private normalizeTaskTaxonomySelections;
+    private listMissingRequiredTaxonomyLabels;
+    private assertRequiredTaskTaxonomies;
     private enforceCreateTaskTaxonomy;
-    private sanitizeParentTaskId;
-    private sanitizeChildDisplayOrder;
+    private sanitizeWorkstreamId;
+    private sanitizeInitiativeId;
     private sanitizeDateOnly;
     private sanitizeOrderInDay;
     private formatDateOnlyUtc;
@@ -470,41 +836,36 @@ export declare class TaskforceCore {
     private todayDateOnlyLocal;
     private normalizeWorkspaceId;
     private buildSchedulingWarnings;
-    private nextChildDisplayOrder;
     private taskExists;
+    private initiativeExists;
+    private workstreamExists;
     private valueEqualsForBulkUpdate;
-    private hasNonTerminalDirectChildren;
-    private hasDirectChildren;
-    private getTaskHierarchyRows;
-    private buildTaskHierarchyIndex;
-    private getDescendantIds;
-    private hasOpenDescendants;
-    private recomputeTaskAndAncestorCompletionFromDescendants;
-    private createsParentCycle;
-    private assertParentLinkAllowed;
+    private assertWorkstreamLinkAllowed;
+    private assertInitiativeLinkAllowed;
     constructor(config: TaskforceConfig);
     close(): void;
     getDatabaseAdapter(): DatabaseAdapter;
     getTenantId(): string;
-    private parseJsonObject;
+    getWorkspaceAssetStore(): WorkspaceAssetStore;
     private normalizeEntitlementState;
-    private normalizeFeatureAccess;
-    private isEntitlementStateAllowed;
-    private ensureDefaultPlanCatalog;
-    private resolvePlanVersionIdForTier;
-    private resolveEntitlementStateForBillingValue;
-    private ensureAccountEntitlementRecord;
-    private backfillAccountEntitlements;
-    createUserBillingRecord(userId: string): void;
+    private upsertCanonicalEntitlementRecord;
+    private resolveWorkspaceLimitForUser;
+    private resolveRegistrationPlanAssignment;
+    createUserBillingRecord(userId: string, options?: {
+        entitlementState?: string;
+        planId?: string | null;
+    }): void;
     getUserEntitlement(userId: string): {
         entitlementState: string;
         tier: string;
     };
-    getEffectivePlanVersion(accountId: string): PlanVersionSnapshot;
-    getAccountEntitlement(accountId: string): AccountEntitlementSnapshot;
+    hasAccountEntitlement(accountId: string): boolean;
+    getAccountAccessStatus(accountId: string): import("./types.js").AccountAccessStatus;
+    getEffectivePlanVersion(accountId: string): import("./types.js").PlanVersionSnapshot;
+    getAccountEntitlement(accountId: string): import("./types.js").AccountEntitlementSnapshot;
     countWorkspaceSeatUsage(workspaceId: string, options?: {
         includeInvited?: boolean;
-    }): SeatUsageSnapshot;
+    }): import("./types.js").SeatUsageSnapshot;
     assertSeatAvailable(workspaceId: string): void;
     evaluateFeatureAccess(input: {
         userId: string;
@@ -512,33 +873,75 @@ export declare class TaskforceCore {
         featureKey: string;
         action?: string;
         context?: Record<string, unknown>;
-    }): FeatureEvaluationResult;
-    getUserAccountPlanMode(userId: string): 'personal' | 'team';
-    setUserAccountPlanMode(userId: string, mode: 'personal' | 'team'): 'personal' | 'team';
+    }): import("./types.js").FeatureEvaluationResult;
+    getUserAccountPlanMode(userId: string): "personal" | "team";
+    setUserAccountPlanMode(userId: string, mode: 'personal' | 'team'): "personal" | "team";
+    getRequiredDefaultPlanVersionId(planId: string): string;
+    getDefaultPlanVersionIdByMode(mode: 'personal' | 'team', options?: {
+        allowFallback?: boolean;
+    }): string;
+    getBillingMirrorProfileForPlanVersion(planVersionId: string): {
+        planId: string;
+        entitlementState: import("./types.js").EntitlementState;
+    };
     private ensureDirectories;
     private migrateLegacyGlobalSettingsDbIfNeeded;
     private initializeSchema;
     private performMigrationIfNeeded;
+    private backfillMcpAuditLogMetadataColumns;
     private migrateSystemRoleBackfillIfNeeded;
     private migrateUserBetaAccessBackfillIfNeeded;
+    private migrateDuplicateAiProfilesIfNeeded;
+    private migrateLegacyActorReferencesIfNeeded;
     private getWorkspaceOwnerUserId;
     getWorkspacePlanMode(workspaceId: string): 'personal' | 'team';
     setWorkspacePlanMode(workspaceId: string, mode: 'personal' | 'team', source?: string): 'personal' | 'team';
+    private readConfigFileOnly;
+    private getWorkspaceBackedProjectConfigKeys;
+    private getUserBackedProjectConfigKeys;
+    private isWorkspaceBackedProjectConfigKey;
+    private isUserBackedProjectConfigKey;
+    private normalizeProjectConfigWorkspaceId;
+    private normalizeProjectConfigUserId;
+    private sanitizeWorkspaceBackedProjectConfig;
+    private sanitizeUserBackedProjectConfig;
+    private stripPersistedProjectConfigKeys;
+    private stripLegacyTaxonomyConfigKeys;
+    private readWorkspaceBackedProjectConfig;
+    private writeWorkspaceBackedProjectConfig;
+    private readUserBackedProjectConfig;
+    private writeUserBackedProjectConfig;
+    private migrateLegacyPersistedProjectConfigIfNeeded;
+    private getTaxonomySettingsServiceDeps;
+    private readStoredWorkspaceTaxonomyState;
+    private writeWorkspaceTaxonomyState;
+    private getLegacyCategoriesConfig;
+    private getLegacyTypesConfig;
+    private resolveDefaultTypeValue;
+    private getLegacyTaxonomiesConfig;
+    private getLegacyPrioritiesConfig;
+    private buildEmergencyWorkspaceTaxonomyState;
+    private getConfiguredDefaultStarterTaxonomyPackId;
+    private getResolvedStarterWorkspaceTaxonomyState;
+    private getEffectiveWorkspaceTaxonomyState;
+    private ensureWorkspaceTaxonomyStateSeeded;
     private readConfig;
+    getConfig(workspaceId?: string, userId?: string): TaskFile['config'];
     private writeConfig;
     private getGlobalSettingsStore;
     private ensureGlobalSettingsTable;
     private ensureStructuredSettingsTables;
     private readSettingsPayloadRow;
-    private splitGlobalSettingsPayload;
     private writeSettingsPayloadRow;
     private hasPersistedGlobalSettings;
     private readGlobalConfig;
     private writeGlobalConfig;
     getGlobalSettings(): GlobalTaskforceSettings;
-    hasProjectThemeOverride(): boolean;
-    getEffectiveTheme(): 'dark' | 'light' | 'midnight';
-    hasProjectJsonBackupOverride(): boolean;
+    hasProjectThemeOverride(workspaceId?: string, userId?: string): boolean;
+    getEffectiveTheme(workspaceId?: string, userId?: string): TaskforceTheme;
+    hasProjectJsonBackupOverride(workspaceId?: string, userId?: string): boolean;
+    getSignupMonetizationSettings(): import("./types.js").SignupMonetizationSettings;
+    validateSignupMonetizationSettings(input?: Partial<SignupMonetizationSettings>): import("./types.js").SignupMonetizationValidationResult;
     updateGlobalSettings(settings: GlobalTaskforceSettings): void;
     private sanitizeUserGlobalSyncSettings;
     getUserGlobalSyncSettings(userId: string): {
@@ -550,8 +953,46 @@ export declare class TaskforceCore {
         updatedAt: string;
         applied: boolean;
     };
-    getJsonBackupEnabled(): boolean;
+    private sanitizeWorkspaceShareableSyncSettings;
+    getWorkspaceShareableSyncSettings(workspaceId: string): {
+        settings: WorkspaceSyncSettingsPayload;
+        updatedAt: string | null;
+    };
+    upsertWorkspaceShareableSyncSettings(workspaceId: string, settings: unknown, updatedAt?: string | null): {
+        settings: WorkspaceSyncSettingsPayload;
+        updatedAt: string | null;
+        applied: boolean;
+    };
+    getJsonBackupEnabled(workspaceId?: string, userId?: string): boolean;
+    private listCanonicalTaskAttachments;
+    private syncCanonicalTaskAttachmentLinks;
     private rowToTask;
+    private rowToInitiative;
+    private rowToWorkstream;
+    private rowToChecklistItem;
+    private sanitizeTaskReferenceNumber;
+    private getTaskByReferenceNumber;
+    resolveTaskIdentifier(value: string, workspaceId?: string): TaskItem | null;
+    getInitiative(id: string, workspaceId?: string): InitiativeItem | null;
+    listInitiatives(workspaceId?: string): InitiativeItem[];
+    createInitiative(input: Partial<InitiativeItem>, workspaceId?: string): InitiativeItem;
+    updateInitiative(id: string, patch: Partial<InitiativeItem>, workspaceId?: string): InitiativeItem;
+    archiveInitiative(id: string, workspaceId?: string): InitiativeItem;
+    unarchiveInitiative(id: string, workspaceId?: string): InitiativeItem;
+    getWorkstream(id: string, workspaceId?: string): WorkstreamItem | null;
+    listWorkstreams(workspaceId?: string): WorkstreamItem[];
+    createWorkstream(input: Partial<WorkstreamItem>, workspaceId?: string): WorkstreamItem;
+    updateWorkstream(id: string, patch: Partial<WorkstreamItem>, workspaceId?: string): WorkstreamItem;
+    archiveWorkstream(id: string, workspaceId?: string): WorkstreamItem;
+    unarchiveWorkstream(id: string, workspaceId?: string): WorkstreamItem;
+    upsertInitiativeForSync(initiative: InitiativeItem, workspaceId?: string | null): InitiativeItem;
+    upsertWorkstreamForSync(workstream: WorkstreamItem, workspaceId?: string | null): WorkstreamItem;
+    listChecklistItems(taskId: string, workspaceId?: string): ChecklistItem[];
+    replaceChecklistItems(taskId: string, items: Array<Partial<ChecklistItem>>, workspaceId?: string): ChecklistItem[];
+    private reserveTaskReferenceNumber;
+    private reserveGenericReferenceNumber;
+    private reserveInitiativeReferenceNumber;
+    private reserveWorkstreamReferenceNumber;
     private generateId;
     private generateEntityId;
     private detectDefaultLocalWorkspaceName;
@@ -586,9 +1027,6 @@ export declare class TaskforceCore {
         projectName: string;
         tenantId: string;
         basePath: string;
-        taskDataDir: string;
-        screenshotsDir: string;
-        contextFilesDir: string;
         mcpScript: string;
     };
     workspaceExists(workspaceId: string): boolean;
@@ -599,11 +1037,26 @@ export declare class TaskforceCore {
         preferredWorkspaceId?: string | null;
         persistedWorkspaceId?: string | null;
     }): string | null;
+    private getWorkspacePreferenceServiceDeps;
+    private getGlobalSettingsServiceDeps;
+    private getAttachmentLinkServiceDeps;
+    private getTaskActivityServiceDeps;
+    private getAnnotatedAttachmentServiceDeps;
+    private getDocumentReviewServiceDeps;
+    private getDeletedTaskLifecycleServiceDeps;
+    private getSyncReconciliationServiceDeps;
+    private getWorkspaceLifecycleServiceDeps;
     listTasks(workspaceId?: string): TaskFile;
     getDataVersion(): number;
     getDatabaseProvider(): DatabaseProvider;
     isDatabaseHealthy(): boolean;
     listArchive(workspaceId?: string): ArchiveFile;
+    listDeletedTasks(workspaceId?: string): {
+        deleted: DeletedTaskRecord[];
+    };
+    getDeletedTask(id: string, workspaceId?: string): DeletedTaskRecord | null;
+    permanentlyDeleteDeletedTask(id: string, workspaceId?: string): boolean;
+    permanentlyDeleteAllDeletedTasks(workspaceId?: string): number;
     getStats(workspaceId?: string): {
         active: {
             total: number;
@@ -628,6 +1081,7 @@ export declare class TaskforceCore {
     }): UserAccessRecord;
     resolveUserAccess(userId: string, workspaceId: string, fallbackRole?: AccessRole): UserAccessRecord | null;
     resolveUserIdentity(userId: string): UserIdentityRecord | null;
+    updateUserDisplayName(userId: string, displayName: string): UserIdentityRecord | null;
     getSystemRole(userId: string): SystemRole;
     getUserBetaAccess(userId: string): boolean;
     countSystemAdmins(): number;
@@ -636,7 +1090,155 @@ export declare class TaskforceCore {
     setSystemRole(userId: string, role: SystemRole): boolean;
     setUserDisabledGlobal(userId: string, disabled: boolean): boolean;
     setUserBetaAccessGlobal(userId: string, enabled: boolean): boolean;
+    private clearActiveAssignmentsForUnavailableActor;
     listWorkspaceUsers(workspaceId: string): WorkspaceUserRecord[];
+    replaceWorkspaceUsersForSync(input: {
+        workspaceId: string;
+        users: WorkspaceUserRecord[];
+        pruneMissing?: boolean;
+    }): WorkspaceUserRecord[];
+    listAiProfiles(workspaceId: string): AiProfileRecord[];
+    getAiProfileByToken(input: {
+        workspaceId: string;
+        profileToken: string;
+    }): AiProfileRecord | null;
+    upsertAiProfileForSync(profile: AiProfileRecord): AiProfileRecord;
+    mergeAiProfiles(input: {
+        workspaceId: string;
+        keepId: string;
+        mergeId: string;
+    }): AiProfileRecord;
+    resolveAiProfile(input: ResolveAiProfileInput): ResolveAiProfileResult;
+    listAnnotatedAttachmentSessions(input: {
+        workspaceId?: string | null;
+        taskId?: string | null;
+        imageAssetId?: string | null;
+        includeDeleted?: boolean;
+    }): AnnotatedAttachmentSession[];
+    getAnnotatedAttachmentSession(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        includeDeleted?: boolean;
+    }): AnnotatedAttachmentSession | null;
+    createAnnotatedAttachmentSession(input: {
+        workspaceId?: string | null;
+        taskId?: string | null;
+        baseImageAssetId: string;
+        title?: string | null;
+        globalInstruction?: string | null;
+        annotations?: AnnotatedAttachmentAnnotation[];
+        actorId?: string | null;
+    }): AnnotatedAttachmentSession;
+    updateAnnotatedAttachmentSession(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        title?: string | null;
+        globalInstruction?: string | null;
+        annotations?: AnnotatedAttachmentAnnotation[];
+        actorId?: string | null;
+    }): AnnotatedAttachmentSession;
+    deleteAnnotatedAttachmentSession(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+    }): boolean;
+    deleteAnnotatedAttachmentSessionsForImage(input: {
+        workspaceId?: string | null;
+        imageAssetId: string;
+        deletedAt?: string | null;
+    }): number;
+    deleteAnnotatedAttachmentSessionsForTaskImage(input: {
+        workspaceId?: string | null;
+        taskId: string;
+        imageAssetId: string;
+        deletedAt?: string | null;
+    }): number;
+    private repairDetachedAnnotatedAttachmentSessions;
+    buildAnnotatedAttachmentPayload(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+    }): AnnotatedAttachmentPayload;
+    listDocumentReviewSessions(input: {
+        workspaceId?: string | null;
+        assetId: string;
+        includeDeleted?: boolean;
+    }): DocumentReviewSession[];
+    getDocumentReviewSession(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        includeDeleted?: boolean;
+    }): DocumentReviewSession | null;
+    listDocumentReviewSessionsForSync(input: {
+        workspaceId?: string | null;
+        includeDeleted?: boolean;
+    }): DocumentReviewSessionRecord[];
+    listDocumentReviewCommentsForSync(input: {
+        workspaceId?: string | null;
+        includeDeleted?: boolean;
+    }): DocumentReviewCommentSyncRecord[];
+    listAnnotatedAttachmentSessionsForSync(input: {
+        workspaceId?: string | null;
+        includeDeleted?: boolean;
+    }): AnnotatedAttachmentSessionRecord[];
+    upsertDocumentReviewSessionForSync(session: DocumentReviewSessionRecord): DocumentReviewSessionRecord;
+    upsertDocumentReviewCommentForSync(comment: DocumentReviewCommentSyncRecord): DocumentReviewCommentSyncRecord;
+    upsertAnnotatedAttachmentSessionForSync(session: AnnotatedAttachmentSessionRecord): AnnotatedAttachmentSessionRecord;
+    deleteDocumentReviewSessionForSync(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        deletedAt?: string | null;
+    }): boolean;
+    deleteDocumentReviewCommentForSync(input: {
+        workspaceId?: string | null;
+        commentId: string;
+        deletedAt?: string | null;
+    }): boolean;
+    deleteAnnotatedAttachmentSessionForSync(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        deletedAt?: string | null;
+    }): boolean;
+    createDocumentReviewSession(input: {
+        workspaceId?: string | null;
+        assetId: string;
+        title?: string | null;
+        status?: DocumentReviewSessionStatus;
+        actorId?: string | null;
+    }): DocumentReviewSession;
+    updateDocumentReviewSession(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        title?: string | null;
+        status?: DocumentReviewSessionStatus;
+        actorId?: string | null;
+    }): DocumentReviewSession;
+    addDocumentReviewComment(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        body: string;
+        anchor?: DocumentReviewAnchor | null;
+        actorId?: string | null;
+    }): DocumentReviewSession;
+    updateDocumentReviewComment(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        commentId: string;
+        body?: string;
+        anchor?: DocumentReviewAnchor | null;
+        actorId?: string | null;
+    }): DocumentReviewSession;
+    deleteDocumentReviewComment(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        commentId: string;
+        actorId?: string | null;
+    }): DocumentReviewSession;
+    deleteDocumentReviewSession(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+    }): boolean;
+    private getAiProfileServiceDeps;
+    resolveWorkspaceActor(workspaceId: string, actorRef: unknown): TaskActor | null;
+    listAssignableActors(workspaceId: string): TaskActor[];
     addAdminAuditLog(input: {
         action: string;
         actorUserId: string;
@@ -644,9 +1246,43 @@ export declare class TaskforceCore {
         workspaceId: string;
         details?: Record<string, unknown>;
     }): void;
-    listAdminAuditLogs(workspaceId: string, limit?: number, offset?: number): AdminAuditLogRecord[];
-    countAdminAuditLogs(workspaceId: string): number;
-    private isValidEntitlementTransition;
+    addMcpAuditLog(input: {
+        workspaceId: string;
+        actorType: 'local' | 'user' | 'token' | 'oauth';
+        actorUserId: string;
+        tokenId?: string | null;
+        toolName: string;
+        details?: Record<string, unknown>;
+    }): void;
+    checkMcpRateLimit(input: {
+        scope: 'actor' | 'workspace';
+        key: string;
+        limit: number;
+        windowMs: number;
+        nowMs?: number;
+    }): {
+        allowed: boolean;
+        limit: number;
+        remaining: number;
+        resetAt: number;
+        retryAfterSeconds: number;
+    };
+    listAdminAuditLogs(workspaceId: string, limit?: number, offset?: number, filters?: {
+        from?: string | null;
+        to?: string | null;
+    }): AdminAuditLogRecord[];
+    countAdminAuditLogs(workspaceId: string, filters?: {
+        from?: string | null;
+        to?: string | null;
+    }): number;
+    listMcpAuditLogs(limit?: number, offset?: number, filters?: {
+        from?: string | null;
+        to?: string | null;
+    }): McpAuditLogRecord[];
+    countMcpAuditLogs(filters?: {
+        from?: string | null;
+        to?: string | null;
+    }): number;
     addEntitlementAuditLog(input: {
         actorUserId: string;
         actorRole: string;
@@ -661,27 +1297,40 @@ export declare class TaskforceCore {
         planId: string;
         displayName: string;
         status?: 'active' | 'archived';
+        initialMode?: 'personal' | 'team';
+        initialSeatLimit?: number | null;
+        initialTrialDays?: number;
     }): {
         planId: string;
         displayName: string;
-        status: 'active' | 'archived';
+        status: "active" | "archived";
     };
-    listPlanCatalog(): PlanCatalogSnapshot[];
-    listPlanVersions(planId: string): PlanVersionSnapshot[];
-    getPlanVersionFeatures(planId: string, versionId: string): PlanVersionSnapshot;
-    searchAccountsByEmail(query: string, limit?: number): Array<{
+    listPlanCatalog(): import("./types.js").PlanCatalogSnapshot[];
+    listPlanFeatureCatalog(): import("./types.js").PlanFeatureCatalogItem[];
+    listPlanVersions(planId: string): import("./types.js").PlanVersionSnapshot[];
+    getPlanVersionFeatures(planId: string, versionId: string): import("./types.js").PlanVersionSnapshot;
+    searchAccountsByEmail(query: string, limit?: number): {
         accountId: string;
         email: string;
         displayName: string | null;
         disabled: boolean;
-    }>;
+    }[];
     createPlanVersion(input: {
         planId: string;
         versionNumber: number;
         isDefault?: boolean;
         seatLimit?: number | null;
+        trialDays?: number;
         metadata?: Record<string, unknown>;
-    }): PlanVersionSnapshot;
+    }): import("./types.js").PlanVersionSnapshot;
+    updatePlanVersion(input: {
+        planId: string;
+        versionNumber: number;
+        isDefault?: boolean;
+        seatLimit?: number | null;
+        trialDays?: number;
+        metadata?: Record<string, unknown>;
+    }): import("./types.js").PlanVersionSnapshot;
     private getPlanVersionSnapshot;
     updatePlanVersionFeatures(input: {
         planVersionId: string;
@@ -690,7 +1339,7 @@ export declare class TaskforceCore {
             access: PlanFeatureAccess;
             config?: Record<string, unknown>;
         }>;
-    }): PlanVersionSnapshot;
+    }): import("./types.js").PlanVersionSnapshot;
     updateAccountEntitlement(input: {
         accountId: string;
         planVersionId?: string;
@@ -701,8 +1350,8 @@ export declare class TaskforceCore {
         actorRole: string;
         reason?: string;
         requestId?: string;
-    }): AccountEntitlementSnapshot;
-    listEntitlementAuditLog(accountId: string, limit?: number, offset?: number): Array<{
+    }): import("./types.js").AccountEntitlementSnapshot;
+    listEntitlementAuditLog(accountId: string, limit?: number, offset?: number): {
         id: string;
         accountId: string;
         action: string;
@@ -712,7 +1361,7 @@ export declare class TaskforceCore {
         before: Record<string, unknown>;
         after: Record<string, unknown>;
         createdAt: string;
-    }>;
+    }[];
     getAccountEntitlementsPayload(input: {
         userId: string;
         workspaceId: string;
@@ -721,13 +1370,13 @@ export declare class TaskforceCore {
         workspaceId: string;
         planId: string;
         planVersionId: string;
-        state: EntitlementState;
+        state: import("./types.js").EntitlementState;
         effectiveAt: string | null;
         effectiveUntil: string | null;
-        seatUsage: SeatUsageSnapshot;
+        seatUsage: import("./types.js").SeatUsageSnapshot;
         features: Record<string, {
             allowed: boolean;
-            access: PlanFeatureAccess;
+            access: import("./types.js").PlanFeatureAccess;
             config: Record<string, unknown>;
         }>;
     };
@@ -766,6 +1415,7 @@ export declare class TaskforceCore {
         email: string;
         password: string;
         workspaceId?: string;
+        planVersionId?: string;
         role?: AccessRole;
         displayName?: string;
         betaAccess?: boolean;
@@ -773,10 +1423,87 @@ export declare class TaskforceCore {
         userId: string;
         workspaceId: string | null;
         role: AccessRole;
+        planSelectionRequired: boolean;
     };
     private createOneTimeAuthToken;
     private consumeOneTimeAuthToken;
     private inspectOneTimeAuthToken;
+    revokeMcpCredentialsForUserWorkspace(userId: string, workspaceId: string, revokedByUserId?: string | null): void;
+    private revokeMcpCredentialsForWorkspace;
+    listMcpAccessTokens(input: {
+        userId: string;
+        workspaceId: string;
+        page?: number;
+        pageSize?: number;
+    }): McpAccessTokenListResult;
+    createMcpAccessToken(input: {
+        userId: string;
+        workspaceId: string;
+        name: string;
+        scopes: unknown;
+        expiresAt?: string | null;
+        createdByIp?: string | null;
+    }): McpAccessTokenIssueResult;
+    revokeMcpAccessToken(input: {
+        actorUserId: string;
+        workspaceId: string;
+        tokenId: string;
+    }): McpAccessTokenRecord;
+    regenerateMcpAccessToken(input: {
+        actorUserId: string;
+        workspaceId: string;
+        tokenId: string;
+        createdByIp?: string | null;
+    }): McpAccessTokenIssueResult;
+    authenticateMcpAccessToken(token: string, workspaceId?: string): McpAccessTokenAuthResult | null;
+    inspectMcpAccessToken(token: string): McpAccessTokenInspectionResult | null;
+    recordMcpAccessTokenUsage(input: {
+        tokenId: string;
+        workspaceId: string;
+        ip?: string | null;
+        userAgent?: string | null;
+    }): boolean;
+    registerMcpOAuthClient(input: {
+        provider: McpOAuthProvider | string;
+        clientName: string;
+        redirectUris: unknown;
+    }): McpOAuthClientRecord;
+    getMcpOAuthClient(clientId: string, provider?: McpOAuthProvider | string | null): McpOAuthClientRecord | null;
+    issueMcpOAuthAuthorizationCode(input: {
+        provider: McpOAuthProvider | string;
+        clientId: string;
+        userId: string;
+        workspaceId: string;
+        scopes: unknown;
+        redirectUri: string;
+        codeChallenge: string;
+        codeChallengeMethod?: string | null;
+    }): {
+        code: string;
+        expiresAt: string;
+    };
+    exchangeMcpOAuthAuthorizationCode(input: {
+        provider: McpOAuthProvider | string;
+        clientId: string;
+        code: string;
+        redirectUri: string;
+        codeVerifier: string;
+    }): McpOAuthTokenExchangeResult;
+    listMcpOAuthConnectorGrants(input: {
+        userId: string;
+        workspaceId: string;
+        provider?: McpOAuthProvider | string | null;
+    }): McpOAuthConnectorGrantRecord[];
+    revokeMcpOAuthConnectorGrant(input: {
+        actorUserId: string;
+        workspaceId: string;
+        grantId: string;
+    }): McpOAuthConnectorGrantRecord;
+    authenticateMcpOAuthAccessToken(token: string, workspaceId?: string): McpOAuthAccessTokenAuthResult | null;
+    recordMcpOAuthConnectorGrantUsage(input: {
+        grantId: string;
+        workspaceId: string;
+    }): boolean;
     isEmailVerified(email: string): boolean;
     markEmailVerified(email: string): boolean;
     requestEmailVerification(input: {
@@ -807,7 +1534,10 @@ export declare class TaskforceCore {
         email?: string;
         userId?: string;
         workspaceId?: string;
+        inviteeKind?: 'existing_user' | 'new_user';
+        passwordRequired?: boolean;
     };
+    private completeInviteWorkspaceActivation;
     acceptInviteWithToken(input: {
         token: string;
         password: string;
@@ -817,6 +1547,15 @@ export declare class TaskforceCore {
         workspaceId: string;
         role: AccessRole;
     };
+    joinInviteWithAuthenticatedUser(input: {
+        token: string;
+        userId: string;
+    }): {
+        userId: string;
+        email: string;
+        workspaceId: string;
+        role: AccessRole;
+    };
     resetPasswordWithToken(input: {
         token: string;
         password: string;
@@ -840,6 +1579,7 @@ export declare class TaskforceCore {
     } | null;
     updateWorkspaceUserRole(userId: string, workspaceId: string, role: AccessRole): boolean;
     getTask(id: string, workspaceId?: string): TaskItem | null;
+    listTaskEvents(taskId: string, workspaceId?: string): TaskEvent[];
     getScheduleBoard(weekKey: string, showWeekends?: boolean, workspaceId?: string): ScheduleBoardResult;
     updateTaskSchedule(id: string, input: {
         scheduledDate: string | null;
@@ -865,14 +1605,25 @@ export declare class TaskforceCore {
     }): BulkCreateTaskResult;
     updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        skipRecompute?: boolean;
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        skipTaskEvents?: boolean;
     }): TaskItem | null;
-    addComment(id: string, text: string, author: string, workspaceId?: string): TaskItem | null;
-    deleteTask(id: string, workspaceId?: string, options?: {
+    addComment(id: string, text: string, author: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
-    }): boolean;
+        actorRef?: string;
+        skipTaskEvents?: boolean;
+    }): TaskItem | null;
+    softDeleteTask(id: string, workspaceId?: string, options?: DeleteTaskOptions): DeletedTaskRecord | null;
+    deleteTask(id: string, workspaceId?: string, options?: DeleteTaskOptions): boolean;
     deleteTaskForSync(id: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
     }): boolean;
+    restoreDeletedTask(id: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        actorRef?: string;
+    }): TaskItem | null;
     listWorkspaceSyncDeletes(workspaceId?: string): Array<{
         taskId: string;
         deletedAt: string;
@@ -893,15 +1644,18 @@ export declare class TaskforceCore {
     }>;
     archiveTask(id: string, isCancellation?: boolean, reason?: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        skipRecompute?: boolean;
+        syncUpdatedAt?: string;
+        skipHierarchyCheck?: boolean;
+        actorRef?: string;
+        skipTaskEvents?: boolean;
     }): TaskItem | null;
     unarchiveTask(id: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
-    }): TaskItem | null;
-    cancelParentWithOpenDescendants(id: string, input: {
-        reason?: string;
-        mode: 'cascade' | 'unlink';
-    }, workspaceId?: string, options?: {
-        persistBackup?: boolean;
+        skipRecompute?: boolean;
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        skipTaskEvents?: boolean;
     }): TaskItem | null;
     bulkArchive(ids: string[], isCancellation?: boolean, workspaceId?: string): number;
     applyWorkspaceSyncSnapshot(input: {
@@ -915,7 +1669,7 @@ export declare class TaskforceCore {
         unarchived: number;
         skipped: number;
     };
-    updateConfig(newConfig: any): void;
+    updateConfig(newConfig: any, workspaceId?: string, userId?: string): void;
     getUiState(workspaceId: string, userId: string, stateKey?: string): Record<string, unknown> | null;
     updateUiState(workspaceId: string, userId: string, input: {
         stateKey?: string;
@@ -923,14 +1677,7 @@ export declare class TaskforceCore {
     }): Record<string, unknown>;
     readPushIdempotency(workspaceId: string, idempotencyKey: string): string | null;
     writePushIdempotency(workspaceId: string, idempotencyKey: string, payload: string): void;
-    recordSyncEvent(workspaceId: string, event: {
-        eventType: 'apply' | 'push' | 'pull' | 'handshake' | 'bootstrap';
-        status: 'success' | 'error';
-        statusCode?: number;
-        errorMessage?: string;
-        changeCount?: number;
-        requestMs?: number;
-    }): void;
+    recordSyncEvent(workspaceId: string, event: SyncEventInput): void;
     listSyncEvents(workspaceId: string, limit?: number): Array<{
         id: number;
         eventType: string;
@@ -939,6 +1686,7 @@ export declare class TaskforceCore {
         errorMessage: string | null;
         changeCount: number | null;
         requestMs: number | null;
+        details: Record<string, unknown> | null;
         occurredAt: string;
     }>;
     /**
@@ -957,24 +1705,38 @@ export declare class TaskforceCore {
      */
     upsertDocumentWatermark(workspaceId: string, docPath: string, contentHash: string, updatedAt: string): void;
     deleteDocumentWatermark(workspaceId: string, docPath: string): void;
-    getCategories(): CategoryConfig[];
-    updateCategories(categories: Array<string | CategoryConfig>): void;
+    notifyDocumentMetadataMutation(workspaceId: string, entityIds: string[], changeType?: 'upsert' | 'delete'): void;
+    getCategories(workspaceId?: string): CategoryConfig[];
+    getTaxonomyState(workspaceId?: string): WorkspaceTaxonomyState;
+    getTaxonomyDisplayLabels(workspaceId?: string): FirstClassTaxonomyDisplayLabels;
+    updateTaxonomyDisplayLabels(displayLabels: FirstClassTaxonomyDisplayLabels, workspaceId?: string): FirstClassTaxonomyDisplayLabels;
+    updateCategories(categories: Array<string | CategoryConfig>, workspaceId?: string): void;
     searchTasks(query: string, scope?: 'all' | 'active' | 'archive', workspaceId?: string): TaskItem[];
-    getTypes(): Array<{
+    getTypes(workspaceId?: string): Array<{
         value: string;
         label: string;
+        color?: string;
+        icon?: string;
+        aliases?: string[];
+        status?: 'active' | 'retired';
     }>;
     updateTypes(types: Array<{
         value: string;
         label: string;
-    }>): void;
-    getTaxonomies(): any[];
-    getTaxonomiesSyncSnapshot(): {
+        color?: string;
+        icon?: string;
+        aliases?: string[];
+        status?: 'active' | 'retired';
+    }>, workspaceId?: string): void;
+    getTaxonomies(workspaceId?: string): any[];
+    getTaxonomiesSyncSnapshot(workspaceId?: string): {
         taxonomies: any[];
+        taxonomyState: WorkspaceTaxonomyState;
         updatedAt: string;
     };
-    updateTaxonomies(taxonomies: any[]): void;
-    getPriorities(): Array<{
+    updateTaxonomyState(taxonomyState: WorkspaceTaxonomyState, workspaceId?: string): WorkspaceTaxonomyState;
+    updateTaxonomies(taxonomies: any[], workspaceId?: string): void;
+    getPriorities(workspaceId?: string): Array<{
         value: number;
         label: string;
         color?: string;
@@ -985,7 +1747,7 @@ export declare class TaskforceCore {
         label: string;
         color?: string;
         icon?: string;
-    }>): void;
+    }>, workspaceId?: string): void;
     getApproaches(): Array<{
         value: string;
         label: string;
@@ -999,7 +1761,6 @@ export declare class TaskforceCore {
         icon?: string;
     }>): void;
     private renderChecklistBlocks;
-    private listDirectChildren;
     getInitiativeTemplates(): InitiativeTemplate[];
     createInitiativeFromTemplate(input: {
         templateId: string;
@@ -1009,24 +1770,12 @@ export declare class TaskforceCore {
         type?: string;
         priority?: number;
         approach?: string;
-        parentTaskId?: string | null;
-        specialists?: string[];
         createdBy?: string;
     }, workspaceId?: string): {
         initiative: TaskItem;
         milestones: TaskItem[];
         templateId: string;
     };
-    cloneChecklistBlocksToChildren(input: {
-        parentTaskId: string;
-        checklistBlocks: {
-            definitionOfDone: string[];
-            rollbackPlan: string[];
-        };
-    }, workspaceId?: string): {
-        updated: number;
-        children: TaskItem[];
-    };
     bulkUpdateType(fromType: string, toType: string, workspaceId?: string): number;
     bulkUpdateFieldsPreview(updates: Array<{
         id: string;
@@ -1049,7 +1798,6 @@ export declare class TaskforceCore {
     };
     exportResources(type: string, destinationRelativePath: string, variables?: Record<string, string>, environment?: string): number;
     exportWorkflows(environment: string, workflowNames?: string[], variables?: any): number;
-    listSpecialists(): any[];
     listWorkflowTemplates(): any[];
     getWorkflowTemplate(name: string): any;
     listWorkflowOverrideNames(): string[];
@@ -1060,4 +1808,3 @@ export declare class TaskforceCore {
      */
     private persistBackup;
 }
-export {};