@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/core/Taskforce.d.ts

@@ -1,9 +1,16 @@
+import { type PlanningIdentityColor, type PlanningIdentityEntityType, type PlanningIdentityIcon } from '../shared/planningIdentity.js';
 import type { DatabaseAdapter, DatabaseProvider } from '../storage/databaseAdapter.js';
+import { type LocalDataOwnerPermit } from '../server/localDataOwnerPermit.js';
+import type { DurableTaskStatusMutationPayload } from './TaskDurableStatusMutationService.js';
 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 { TaskRestoreDestination } from '../shared/taskRestoreDestination.js';
 import { type SyncEventInput } from './SyncReconciliationService.js';
-import { type FirstClassTaxonomyDisplayLabels, type WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
+import { type FirstClassTaxonomyDisplayLabels, type NormalizedWorkspaceTaxonomyState, type WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
 import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
 import { type AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
+import type { AiProfileColorSource } from '../shared/aiProfileColors.js';
 import type { PlanningBootstrapPayload } from '../types.js';
 import type { TaskActor } from '../shared/taskActor.js';
 export type { TaskActor } from '../shared/taskActor.js';
@@ -20,7 +27,7 @@ export interface PlanningBootstrapDiagnostics {
     taskSummaryBuildMs?: number;
 }
 import type { AnnotatedAttachmentAnnotation, AnnotatedAttachmentPayload, AnnotatedAttachmentSession, AnnotatedAttachmentSessionRecord } from '../annotatedAttachments/types.js';
-import type { DocumentReviewAnchor, DocumentReviewCommentSyncRecord, DocumentReviewSession, DocumentReviewSessionRecord, DocumentReviewSessionStatus } from '../documentReviews/types.js';
+import type { DocumentReviewAnchor, DocumentReviewCommentSyncRecord, DocumentReviewSession, DocumentReviewSessionRecord, DocumentReviewSessionStatus, DocumentReviewThreadStatus } from '../documentReviews/types.js';
 import { type TaskforceTheme } from '../utils/theme.js';
 /**
  * Taskforce Core Logic
@@ -112,6 +119,14 @@ export interface DeletedTaskRecord {
     taskSnapshot: TaskItem;
     actorProfile?: TaskActor | null;
 }
+export interface WorkspaceSyncTaskDeleteRecord {
+    taskId: string;
+    deletedAt: string;
+    actor?: string;
+    actorType?: 'human' | 'ai' | 'system';
+    source?: DeletedTaskSource;
+    details?: DeletedTaskDetails;
+}
 export type TaskStatus = 'task' | 'on-hold' | 'in-progress' | 'review' | 'done' | 'cancelled';
 export type TaskAssignee = string;
 export interface TaskItem {
@@ -126,7 +141,6 @@ export interface TaskItem {
     priority: number;
     complexity: number;
     status: TaskStatus;
-    approach?: string;
     createdAt: string;
     updatedAt?: string;
     completedAt?: string | null;
@@ -138,6 +152,7 @@ export interface TaskItem {
     activity?: TaskActivityItem[];
     taskEvents?: TaskEvent[];
     attachments?: AttachmentItem[];
+    cardCoverAssetId?: string | null;
     /** @deprecated Use status='done'. Safe to remove after v0.4.x migration gate. */
     completed?: boolean;
     /** @deprecated Use status='cancelled'. Safe to remove after v0.4.x migration gate. */
@@ -147,12 +162,13 @@ export interface TaskItem {
     createdByActor?: TaskActor | null;
     assignee?: TaskAssignee;
     assigneeActor?: TaskActor | null;
-    canceledReason?: string;
+    canceledReason?: string | null;
     isArchived?: boolean;
     scheduledDate?: string | null;
     dueDate?: string | null;
     scheduledWeekKey?: string | null;
     orderInDay?: number | null;
+    workstreamOrder?: number | null;
     workstreamId?: string | null;
     checklistItems?: ChecklistItem[];
 }
@@ -167,6 +183,7 @@ export type AttachmentItem = string | {
     referenceNumber?: number | null;
     referenceLabel?: string | null;
     taskId?: string | null;
+    linkRole?: 'attachment' | 'image' | 'reference';
 };
 export interface InitiativeItem {
     id: string;
@@ -175,6 +192,9 @@ export interface InitiativeItem {
     title: string;
     description: string | null;
     ownerId?: string | null;
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+    identityUpdatedAt?: string | null;
     comments?: Comment[];
     activity?: EntityActivityItem[];
     entityEvents?: PlanningEntityEvent[];
@@ -192,6 +212,9 @@ export interface WorkstreamItem {
     title: string;
     description: string | null;
     ownerId?: string | null;
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+    identityUpdatedAt?: string | null;
     comments?: Comment[];
     activity?: EntityActivityItem[];
     entityEvents?: PlanningEntityEvent[];
@@ -201,6 +224,13 @@ export interface WorkstreamItem {
     order?: number | null;
     isArchived?: boolean;
 }
+export interface PlanningEntityIdentityRecord {
+    entityType: PlanningIdentityEntityType;
+    entityId: string;
+    icon: PlanningIdentityIcon | null;
+    color: PlanningIdentityColor | null;
+    updatedAt: string;
+}
 export interface ChecklistItem {
     id: string;
     taskId: string;
@@ -239,7 +269,7 @@ export interface ScheduleBoardResult {
         }>;
     };
 }
-export type RealtimeMutationEntityType = 'task' | 'taxonomy' | 'document-metadata';
+export type RealtimeMutationEntityType = 'task' | 'initiative' | 'workstream' | 'taxonomy' | 'document-metadata';
 export interface RealtimeMutationEvent {
     eventId: string;
     workspaceId: string;
@@ -249,9 +279,19 @@ export interface RealtimeMutationEvent {
     entityType: RealtimeMutationEntityType;
     changeType: string;
     entityIds: string[];
+    affectedCollections?: Array<'active' | 'archive' | 'deleted' | 'planning'>;
+    lifecycleTransition?: string;
     dataVersion: number;
     serverTs: string;
 }
+export interface WorkspaceMutationCommittedEvent {
+    workspaceId: string;
+    origin: 'local' | 'workspace-sync-apply';
+}
+export interface WorkspaceSyncSideEffectBatch {
+    commit(): void;
+    rollback(): void;
+}
 export declare class TaskforceRuleError extends Error {
     statusCode: number;
     code: string;
@@ -274,6 +314,8 @@ export interface TaskforceConfig {
     storagePath?: string;
     tenantId?: string;
     runtimeMode?: RuntimeMode;
+    initializationMode?: 'standard' | 'cloud-read-worker';
+    localDataOwnerPermit?: LocalDataOwnerPermit;
     database?: {
         provider?: DatabaseProvider;
         connectionString?: string;
@@ -303,12 +345,6 @@ export interface TaskFile {
             color?: string;
             icon?: string;
         }>;
-        approaches?: Array<{
-            value: string;
-            label: string;
-            color?: string;
-            icon?: string;
-        }>;
         theme?: TaskforceTheme;
         shortcut?: string;
         jsonBackupEnabled?: boolean;
@@ -361,7 +397,6 @@ export interface InitiativeTemplateMilestone {
     title: string;
     description: string;
     priority?: number;
-    approach?: string;
     category?: string;
 }
 export interface InitiativeTemplate {
@@ -381,7 +416,7 @@ type PermissionMode = 'read-only' | 'read-write';
 type AuthTokenPurpose = 'email_verification' | 'password_reset' | 'invite_accept';
 export type McpAccessTokenScope = 'tasks:read' | 'tasks:write' | 'workspace:read';
 type McpAccessTokenStatus = 'active' | 'revoked' | 'expired';
-export type McpOAuthProvider = 'chatgpt' | 'claude';
+export type McpOAuthProvider = 'chatgpt' | 'claude' | 'grok' | 'gemini' | 'mistral' | 'perplexity';
 type McpOAuthClientStatus = 'active' | 'revoked';
 type McpOAuthGrantStatus = 'active' | 'revoked';
 interface UserAccessRecord {
@@ -453,6 +488,8 @@ export interface AiProfileRecord {
     username: string;
     icon: string;
     color: string;
+    colorSource?: AiProfileColorSource | null;
+    colorUpdatedAt?: string | null;
     avatarUrl?: string | null;
     avatarSourceUrl?: string | null;
     avatarRevision?: number;
@@ -488,6 +525,8 @@ export interface ResolveAiProfileInput {
 }
 export interface ResolveAiProfileOptions {
     trustedSeatScope?: AiProfileSeatScope | null;
+    trustedSignatureColor?: string | null;
+    trustedSurfaceType?: AiProfileSurfaceType | null;
 }
 export interface ResolveAiProfileResult {
     created: boolean;
@@ -567,6 +606,7 @@ interface WorkspaceProfileUpdateInput {
 }
 interface CreateTaskOptions {
     persistBackup?: boolean;
+    emitRealtime?: boolean;
     workspaceId?: string;
     allowClientProvidedId?: boolean;
     provisionalLocalReference?: boolean;
@@ -575,6 +615,10 @@ interface CreateTaskOptions {
     syncUpdatedAt?: string;
     actorRef?: string;
     skipTaskEvents?: boolean;
+    taskEventId?: string;
+    durableProvisionalCreate?: boolean;
+    allowV3OwnedCreate?: boolean;
+    preferExplicitAttachmentAssetId?: boolean;
 }
 interface DeleteTaskOptions {
     persistBackup?: boolean;
@@ -727,6 +771,7 @@ export interface McpOAuthClientRecord {
     id: string;
     provider: McpOAuthProvider;
     clientName: string;
+    productClientId?: string | null;
     redirectUris: string[];
     status: McpOAuthClientStatus;
     createdAt: string;
@@ -737,6 +782,7 @@ export interface McpOAuthConnectorGrantRecord {
     provider: McpOAuthProvider;
     clientId: string;
     clientName: string;
+    productClientId?: string | null;
     workspaceId: string;
     userId: string;
     scopes: McpAccessTokenScope[];
@@ -760,6 +806,7 @@ export interface McpOAuthAccessTokenAuthResult {
     userId: string;
     clientId: string;
     provider: McpOAuthProvider;
+    productClientId?: string | null;
     scopes: McpAccessTokenScope[];
     status: McpOAuthGrantStatus;
     aiProfileId?: string | null;
@@ -772,19 +819,33 @@ export interface McpOAuthAccessTokenAuthResult {
  * type safety instead of relying on `(core as any)` casts.
  */
 export interface TaskforceSyncCapable {
+    claimPushIdempotency(workspaceId: string, idempotencyKey: string, claimToken: string): import('./SyncReconciliationService.js').PushIdempotencyClaimResult;
+    completePushIdempotencyClaim(workspaceId: string, idempotencyKey: string, claimToken: string, payload: string): boolean;
     readPushIdempotency(workspaceId: string, idempotencyKey: string): string | null;
+    releasePushIdempotencyClaim(workspaceId: string, idempotencyKey: string, claimToken: string): void;
+    renewPushIdempotencyClaim(workspaceId: string, idempotencyKey: string, claimToken: string): boolean;
     writePushIdempotency(workspaceId: string, idempotencyKey: string, payload: string): void;
     getDatabaseAdapter(): DatabaseAdapter;
     getTenantId(): string;
+    beginWorkspaceSyncSideEffectBatch(): WorkspaceSyncSideEffectBatch;
     getDocumentWatermark(workspaceId: string, docPath: string): {
         updatedAt: string;
         contentHash: string;
     } | null;
     upsertDocumentWatermark(workspaceId: string, docPath: string, contentHash: string, updatedAt: string): void;
+    upsertDocumentWatermarkStrict(workspaceId: string, docPath: string, contentHash: string, updatedAt: string): void;
     deleteDocumentWatermark(workspaceId: string, docPath: string): void;
+    deleteDocumentWatermarkStrict(workspaceId: string, docPath: string): void;
     onRealtimeMutation(listener: (event: RealtimeMutationEvent) => void): () => void;
+    onWorkspaceMutationCommitted(listener: (event: WorkspaceMutationCommittedEvent) => void): () => void;
     deleteTaskForSync(id: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        emitRealtime?: boolean;
+        deletedAt?: string;
+        actor?: string;
+        actorType?: 'human' | 'ai' | 'system';
+        source?: DeletedTaskSource;
+        details?: DeletedTaskDetails;
     }): boolean;
     notifyDocumentMetadataMutation(workspaceId: string, entityIds: string[], changeType?: 'upsert' | 'delete'): void;
     listTasksForSync(workspaceId: string | undefined, cursor: {
@@ -797,10 +858,7 @@ export interface TaskforceSyncCapable {
     listWorkspaceSyncDeletesSince(workspaceId: string | undefined, cursor: {
         watermark: string;
         id: string;
-    } | null, limit: number): Array<{
-        taskId: string;
-        deletedAt: string;
-    }>;
+    } | null, limit: number): WorkspaceSyncTaskDeleteRecord[];
     listWorkspaceSyncDeletes(workspaceId?: string): Array<{
         taskId: string;
         deletedAt: string;
@@ -811,7 +869,11 @@ export interface TaskforceSyncCapable {
         updatedAt: string;
     };
     listInitiatives(workspaceId?: string): InitiativeItem[];
+    listInitiativesForSync(workspaceId: string | undefined, afterId: string | null, limit: number): InitiativeItem[];
     listWorkstreams(workspaceId?: string): WorkstreamItem[];
+    listWorkstreamsForSync(workspaceId: string | undefined, afterId: string | null, limit: number): WorkstreamItem[];
+    listPlanningEntityIdentities(workspaceId?: string): PlanningEntityIdentityRecord[];
+    applyPlanningEntityIdentityForSync(identity: PlanningEntityIdentityRecord, workspaceId?: string | null): PlanningEntityIdentityRecord | null;
     listAiProfiles(workspaceId: string, options?: {
         includeArchived?: boolean;
     }): AiProfileRecord[];
@@ -839,6 +901,11 @@ export interface TaskforceSyncCapable {
     taskExistsForSync(id: string, workspaceId?: string | null): boolean;
     listEntityEventsForSync(input: {
         workspaceId?: string | null;
+        cursor?: {
+            watermark: string;
+            id: string;
+        } | null;
+        limit?: number;
     }): EntityEvent[];
     getEntityEventForSync(input: {
         workspaceId?: string | null;
@@ -857,7 +924,17 @@ export interface TaskforceSyncCapable {
     upsertDocumentReviewCommentForSync(comment: DocumentReviewCommentSyncRecord): DocumentReviewCommentSyncRecord;
     upsertAnnotatedAttachmentSessionForSync(session: AnnotatedAttachmentSessionRecord): AnnotatedAttachmentSessionRecord;
     upsertTaskEventForSync(event: TaskEvent): TaskEvent;
-    upsertEntityEventForSync(event: EntityEvent): EntityEvent;
+    upsertEntityEventForSync(event: EntityEvent, options?: {
+        allowAuthoritativeReplacement?: boolean;
+    }): EntityEvent;
+    addTaskCommentEventForDurableSync(event: {
+        taskId: string;
+        workspaceId: string;
+        actor: string;
+        eventId: string;
+        createdAt: string;
+        comment: Comment;
+    }): void;
     deleteDocumentReviewSessionForSync(input: {
         workspaceId?: string | null;
         sessionId: string;
@@ -895,13 +972,50 @@ export interface TaskforceSyncCapable {
         profileId: string;
         surfaceType?: AiProfileSurfaceType | null;
     }): AiProfileRecord;
+    updateAiProfileColorGroup(input: {
+        workspaceId: string;
+        profileIds: string[];
+        color?: string | null;
+        reset?: boolean;
+        allowTaskforceManaged?: boolean;
+    }): AiProfileRecord[];
+    updateAiProfileProviderMetadata(input: {
+        workspaceId: string;
+        profileId: string;
+        providerMetadata?: Record<string, unknown> | null;
+    }): AiProfileRecord;
+    bindAiProfileConnection(input: {
+        workspaceId: string;
+        profileId: string;
+        connectionId: string;
+        clientId?: string | null;
+    }): AiProfileRecord;
+    getAiProfileByConnection(input: {
+        workspaceId: string;
+        connectionId: string;
+        seatScope?: AiProfileSeatScope | null;
+        repairLegacyBinding?: boolean;
+    }): AiProfileRecord | null;
     resolveWorkspaceActor(workspaceId: string, actorRef: unknown): TaskActor | null;
 }
+export type TaskRelationshipInputType = 'depends_on' | 'blocks' | 'related_to' | 'supersedes';
+export type TaskRelationshipKind = 'dependency' | 'related' | 'supersedes';
+export interface TaskRelationshipRecord {
+    id: string;
+    workspaceId: string;
+    sourceTaskId: string;
+    targetTaskId: string;
+    kind: TaskRelationshipKind;
+    createdBy: string | null;
+    createdAt: string;
+    updatedBy: string | null;
+    updatedAt: string;
+    deletedBy: string | null;
+    deletedAt: string | 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;
@@ -917,11 +1031,20 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     private identityService;
     private mcpTokenService;
     private planEntitlementService;
+    private workspaceSyncPublishedContentResolver;
     private realtimeMutationListeners;
+    private workspaceMutationCommittedListeners;
     private readonly realtimeServerEpoch;
     private realtimeMutationSeq;
+    private observedDatabaseDataVersion;
+    private dataVersionSequence;
+    private workspaceSyncSideEffectBatch;
+    private lastAdminAuditRetentionRun;
     private emitRealtimeMutation;
+    beginWorkspaceSyncSideEffectBatch(): WorkspaceSyncSideEffectBatch;
     onRealtimeMutation(listener: (event: RealtimeMutationEvent) => void): () => void;
+    onWorkspaceMutationCommitted(listener: (event: WorkspaceMutationCommittedEvent) => void): () => void;
+    private emitWorkspaceMutationCommitted;
     private normalizePriorityValue;
     private normalizePriorityDefinitions;
     private normalizePriorityConfigIfNeeded;
@@ -961,10 +1084,8 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     private replaceEntityEvents;
     private replaceTaskEvents;
     private mapDeletedTaskRow;
-    private pruneDeletedTasks;
     private normalizeTaskSnapshotForRestore;
     private addDeletedTaskRecord;
-    private purgeExpiredDeletedTasks;
     private areTaskEventValuesEqual;
     private normalizeTaskEventValue;
     private buildTaskUpdateChanges;
@@ -988,6 +1109,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     private sanitizeInitiativeId;
     private sanitizeDateOnly;
     private sanitizeOrderInDay;
+    private nextWorkstreamTaskOrder;
     private formatDateOnlyUtc;
     private parseDateOnlyUtc;
     private dateOnlyToIsoWeekKey;
@@ -1009,6 +1131,22 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     getDatabaseAdapter(): DatabaseAdapter;
     getTenantId(): string;
     getWorkspaceAssetStore(): WorkspaceAssetStore;
+    private resolveWorkspaceAssetPublishedContent;
+    getWorkspaceAssetDispatchReadiness(assetId: string, workspaceId: string): {
+        ready: boolean;
+        retryable: boolean;
+        reason: string;
+    };
+    listTaskAttachmentLinksForDurableSync(taskId: string, workspaceId: string): WorkspaceSyncV3TaskAttachmentLink[];
+    listWorkspaceTaskAttachmentLinksForDurableSync(taskIds: ReadonlySet<string>, workspaceId: string): Map<string, WorkspaceSyncV3TaskAttachmentLink[]>;
+    normalizeTaskAttachmentDescriptorsForDurableSync(attachments: readonly AttachmentItem[], workspaceId: string, options?: {
+        requireDispatchReady?: boolean;
+    }): WorkspaceSyncV3TaskAttachmentLink[];
+    resolveTaskAttachmentLinksForDurableSync(links: readonly WorkspaceSyncV3TaskAttachmentLink[], workspaceId: string, options?: {
+        requireDispatchReady?: boolean;
+        adoptAuthoritativeReferenceNumber?: boolean;
+        ignoreAssetMetadataSnapshots?: boolean;
+    }): AttachmentItem[];
     private normalizeEntitlementState;
     private upsertCanonicalEntitlementRecord;
     transitionCanonicalCommercialState(input: {
@@ -1163,44 +1301,79 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     resolveTaskIdentifier(value: string, workspaceId?: string): TaskItem | null;
     getInitiative(id: string, workspaceId?: string): InitiativeItem | null;
     listInitiatives(workspaceId?: string): InitiativeItem[];
+    listInitiativesForSync(workspaceId: string | undefined, afterId: string | null, limit: number): InitiativeItem[];
     private isTransientPlanningHydrationError;
     private getInitiativeForWriteResult;
     private getWorkstreamForWriteResult;
     createInitiative(input: Partial<InitiativeItem>, workspaceId?: string, options?: {
         actorRef?: string;
         skipEntityEvents?: boolean;
+        entityEventId?: string;
+        durableProvisionalCreate?: boolean;
+        allowV3OwnedWrite?: boolean;
     }): InitiativeItem;
     updateInitiative(id: string, patch: Partial<InitiativeItem>, workspaceId?: string, options?: {
         actorRef?: string;
         skipEntityEvents?: boolean;
+        entityEventId?: string;
+        allowV3OwnedWrite?: boolean;
     }): InitiativeItem;
     archiveInitiative(id: string, workspaceId?: string, options?: {
         actorRef?: string;
         skipEntityEvents?: boolean;
+        entityEventId?: string;
+        updatedAt?: string;
+        allowV3OwnedWrite?: boolean;
     }): InitiativeItem;
     unarchiveInitiative(id: string, workspaceId?: string, options?: {
         actorRef?: string;
         skipEntityEvents?: boolean;
+        entityEventId?: string;
+        updatedAt?: string;
+        allowV3OwnedWrite?: boolean;
     }): InitiativeItem;
     getWorkstream(id: string, workspaceId?: string): WorkstreamItem | null;
     listWorkstreams(workspaceId?: string): WorkstreamItem[];
+    listWorkstreamsForSync(workspaceId: string | undefined, afterId: string | null, limit: number): WorkstreamItem[];
+    listPlanningEntityIdentities(workspaceId?: string): PlanningEntityIdentityRecord[];
+    private writePlanningEntityIdentity;
+    updatePlanningEntityIdentity(entityType: PlanningIdentityEntityType, entityId: string, patch: {
+        icon?: unknown;
+        color?: unknown;
+    }, workspaceId?: string): InitiativeItem | WorkstreamItem;
+    applyPlanningEntityIdentityForSync(identity: PlanningEntityIdentityRecord, workspaceId?: string | null): PlanningEntityIdentityRecord | null;
     listPlanningBootstrap(workspaceId?: string, diagnostics?: PlanningBootstrapDiagnostics): PlanningBootstrapPayload;
     createWorkstream(input: Partial<WorkstreamItem>, workspaceId?: string, options?: {
         actorRef?: string;
         skipEntityEvents?: boolean;
+        entityEventId?: string;
+        durableProvisionalCreate?: boolean;
+        allowV3OwnedWrite?: boolean;
+        allowLegacySyncWriteAfterV2Rollback?: boolean;
     }): WorkstreamItem;
     updateWorkstream(id: string, patch: Partial<WorkstreamItem>, workspaceId?: string, options?: {
         actorRef?: string;
         skipEntityEvents?: boolean;
+        entityEventId?: string;
+        allowV3OwnedWrite?: boolean;
+        allowLegacySyncWriteAfterV2Rollback?: boolean;
     }): WorkstreamItem;
     archiveWorkstream(id: string, workspaceId?: string, options?: {
         actorRef?: string;
         skipEntityEvents?: boolean;
+        entityEventId?: string;
+        updatedAt?: string;
+        allowV3OwnedWrite?: boolean;
     }): WorkstreamItem;
     unarchiveWorkstream(id: string, workspaceId?: string, options?: {
         actorRef?: string;
         skipEntityEvents?: boolean;
+        entityEventId?: string;
+        updatedAt?: string;
+        allowV3OwnedWrite?: boolean;
     }): WorkstreamItem;
+    private isPlanningCommentReplacementCharacterRepair;
+    private mergePlanningCommentsForSync;
     upsertInitiativeForSync(initiative: InitiativeItem, workspaceId?: string | null): InitiativeItem;
     upsertWorkstreamForSync(workstream: WorkstreamItem, workspaceId?: string | null): WorkstreamItem;
     listChecklistItems(taskId: string, workspaceId?: string): ChecklistItem[];
@@ -1289,7 +1462,25 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         sort?: 'created' | 'priority' | 'updated';
         order?: 'asc' | 'desc';
         limit?: number;
+        offset?: number;
+        workstreamId?: string;
+        includeArchived?: boolean;
     }): Array<Record<string, unknown>>;
+    listTaskCountsByWorkstream(workspaceId?: string, workstreamId?: string): Array<{
+        workstreamId: string;
+        total: number;
+        active: number;
+        archived: number;
+    }>;
+    listTaskReferenceSummaries(taskIds: string[], workspaceId?: string): Array<{
+        id: string;
+        referenceNumber: number | null;
+        localReferenceNumber: number | null;
+        referenceLabel: string | null;
+        title: string;
+        status: TaskStatus;
+    }>;
+    searchTaskSummaries(query: string, scope?: 'all' | 'active' | 'archive', workspaceId?: string): Array<Record<string, unknown>>;
     getDataVersion(): number;
     getDatabaseProvider(): DatabaseProvider;
     isDatabaseHealthy(): boolean;
@@ -1297,7 +1488,11 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     listDeletedTasks(workspaceId?: string): {
         deleted: DeletedTaskRecord[];
     };
+    listDeletedTasksReadOnly(workspaceId?: string): {
+        deleted: DeletedTaskRecord[];
+    };
     getDeletedTask(id: string, workspaceId?: string): DeletedTaskRecord | null;
+    private assertNoDurableTaskDeleteOwnership;
     permanentlyDeleteDeletedTask(id: string, workspaceId?: string): boolean;
     permanentlyDeleteAllDeletedTasks(workspaceId?: string): number;
     getStats(workspaceId?: string): {
@@ -1311,6 +1506,13 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
             doneCount: number;
             cancelledCount: number;
         };
+        deleted: {
+            total: number;
+            doneCount: number;
+            cancelledCount: number;
+            otherCount: number;
+            retentionDays: number;
+        };
     };
     private normalizeAccessRole;
     private normalizeSystemRole;
@@ -1381,6 +1583,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         actorUserId: string;
         emailConfirmation: string;
     }): PurgedSystemUserSummary;
+    private assertNoDurablePlanningOwnershipForActor;
     private clearActiveAssignmentsForUnavailableActor;
     listWorkspaceUsers(workspaceId: string): WorkspaceUserRecord[];
     replaceWorkspaceUsersForSync(input: {
@@ -1423,6 +1626,30 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         profileId: string;
         surfaceType?: AiProfileSurfaceType | null;
     }): AiProfileRecord;
+    updateAiProfileColorGroup(input: {
+        workspaceId: string;
+        profileIds: string[];
+        color?: string | null;
+        reset?: boolean;
+        allowTaskforceManaged?: boolean;
+    }): AiProfileRecord[];
+    updateAiProfileProviderMetadata(input: {
+        workspaceId: string;
+        profileId: string;
+        providerMetadata?: Record<string, unknown> | null;
+    }): AiProfileRecord;
+    bindAiProfileConnection(input: {
+        workspaceId: string;
+        profileId: string;
+        connectionId: string;
+        clientId?: string | null;
+    }): AiProfileRecord;
+    getAiProfileByConnection(input: {
+        workspaceId: string;
+        connectionId: string;
+        seatScope?: AiProfileSeatScope | null;
+        repairLegacyBinding?: boolean;
+    }): AiProfileRecord | null;
     resolveAiProfile(input: ResolveAiProfileInput, options?: ResolveAiProfileOptions): ResolveAiProfileResult;
     listAnnotatedAttachmentSessions(input: {
         workspaceId?: string | null;
@@ -1447,6 +1674,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     updateAnnotatedAttachmentSession(input: {
         workspaceId?: string | null;
         sessionId: string;
+        taskId?: string | null;
         title?: string | null;
         globalInstruction?: string | null;
         annotations?: AnnotatedAttachmentAnnotation[];
@@ -1461,13 +1689,6 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         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;
@@ -1495,10 +1716,18 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         includeDeleted?: boolean;
     }): AnnotatedAttachmentSessionRecord[];
     upsertDocumentReviewSessionForSync(session: DocumentReviewSessionRecord): DocumentReviewSessionRecord;
-    upsertDocumentReviewCommentForSync(comment: DocumentReviewCommentSyncRecord): DocumentReviewCommentSyncRecord;
+    upsertDocumentReviewCommentForSync(comment: Omit<DocumentReviewCommentSyncRecord, 'parentCommentId' | 'threadStatus' | 'threadStatusUpdatedAt' | 'resolvedAt' | 'resolvedByActorId'> & Partial<Pick<DocumentReviewCommentSyncRecord, 'parentCommentId' | 'threadStatus' | 'threadStatusUpdatedAt' | 'resolvedAt' | 'resolvedByActorId'>>): DocumentReviewCommentSyncRecord;
     upsertAnnotatedAttachmentSessionForSync(session: AnnotatedAttachmentSessionRecord): AnnotatedAttachmentSessionRecord;
     upsertTaskEventForSync(event: TaskEvent): TaskEvent;
-    upsertEntityEventForSync(event: EntityEvent): EntityEvent;
+    upsertEntityEventForSync(event: EntityEvent, options?: {
+        allowAuthoritativeReplacement?: boolean;
+    }): EntityEvent;
+    deleteEntityEventForSync(input: {
+        workspaceId: string;
+        eventId: string;
+        entityType: string;
+        entityId: string;
+    }): boolean;
     deleteDocumentReviewSessionForSync(input: {
         workspaceId?: string | null;
         sessionId: string;
@@ -1508,6 +1737,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         workspaceId?: string | null;
         commentId: string;
         deletedAt?: string | null;
+        deletedByActorId?: string | null;
     }): boolean;
     deleteAnnotatedAttachmentSessionForSync(input: {
         workspaceId?: string | null;
@@ -1534,6 +1764,25 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         body: string;
         anchor?: DocumentReviewAnchor | null;
         actorId?: string | null;
+        idempotencyKey?: string | null;
+        commentId?: string | null;
+    }): DocumentReviewSession;
+    addDocumentReviewReply(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        parentCommentId: string;
+        body: string;
+        actorId?: string | null;
+        idempotencyKey?: string | null;
+        commentId?: string | null;
+    }): DocumentReviewSession;
+    updateDocumentReviewThreadStatus(input: {
+        workspaceId?: string | null;
+        sessionId: string;
+        commentId: string;
+        status: DocumentReviewThreadStatus;
+        actorId?: string | null;
+        canModerate?: boolean;
     }): DocumentReviewSession;
     updateDocumentReviewComment(input: {
         workspaceId?: string | null;
@@ -1548,6 +1797,8 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         sessionId: string;
         commentId: string;
         actorId?: string | null;
+        canModerate?: boolean;
+        cascade?: boolean;
     }): DocumentReviewSession;
     deleteDocumentReviewSession(input: {
         workspaceId?: string | null;
@@ -1563,6 +1814,11 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         workspaceId: string;
         details?: Record<string, unknown>;
     }): void;
+    pruneAdminAuditLogs(now?: Date): AdminAuditRetentionRun;
+    getAdminAuditRetentionDiagnostics(now?: Date): AdminAuditRetentionDiagnostics & {
+        policy: ReturnType<typeof resolveAdminAuditRetentionPolicy>;
+        lastRun: AdminAuditRetentionRun | null;
+    };
     addMcpAuditLog(input: {
         workspaceId: string;
         actorType: 'local' | 'user' | 'token' | 'oauth';
@@ -1811,7 +2067,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     }): string;
     /**
      * Lists all active login identities for a user.
-     * Used by the Account Hub "Login methods" section.
+     * Used by the Account Settings "Login methods" section.
      */
     listLoginMethodsForUser(userId: string): import('./types.js').UserAuthIdentity[];
     /**
@@ -1819,11 +2075,9 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
      * Throws LAST_IDENTITY_REQUIRED if it would be the last active method.
      */
     unlinkLoginMethod(userId: string, provider: UserAuthProvider): boolean;
-    /**
-     * Adds or replaces a password identity for a user that signed up via OAuth.
-     * Uses upsert semantics (safe to call on accounts that already have a password).
-     */
+    /** Adds a password identity to an account that does not already have one. */
     addPasswordToAccount(userId: string, password: string): string;
+    changePassword(userId: string, currentPassword: string, newPassword: string): string;
     /**
      * Registers a new user account via an OAuth provider (no password).
      *
@@ -1906,6 +2160,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         provider: McpOAuthProvider | string;
         clientName: string;
         redirectUris: unknown;
+        productClientId?: string | null;
     }): McpOAuthClientRecord;
     getMcpOAuthClient(clientId: string, provider?: McpOAuthProvider | string | null): McpOAuthClientRecord | null;
     issueMcpOAuthAuthorizationCode(input: {
@@ -1946,6 +2201,10 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         profileToken: string;
         profileName: string;
     }): boolean;
+    listMcpOAuthRestorableAiProfileIds(input: {
+        grantId: string;
+        workspaceId: string;
+    }): string[];
     recordMcpOAuthConnectorGrantUsage(input: {
         grantId: string;
         workspaceId: string;
@@ -2053,6 +2312,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         workspaceId?: string | null;
         action: string;
         actor?: unknown;
+        eventId?: string;
         createdAt?: string;
         details?: TaskEventDetails;
     }): void;
@@ -2066,6 +2326,11 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     }): TaskEvent | null;
     listEntityEventsForSync(input: {
         workspaceId?: string | null;
+        cursor?: {
+            watermark: string;
+            id: string;
+        } | null;
+        limit?: number;
     }): EntityEvent[];
     getEntityEventForSync(input: {
         workspaceId?: string | null;
@@ -2079,6 +2344,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         task: TaskItem;
         warnings: TaskWarning[];
     } | null;
+    getTaskSchedulingWarnings(task: TaskItem): TaskWarning[];
     reorderScheduledTasks(moves: Array<{
         id: string;
         scheduledDate: string | null;
@@ -2087,7 +2353,21 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         tasks: TaskItem[];
         warnings: TaskWarning[];
     };
+    replaceWorkstreamTaskOrder(workstreamId: string, orderedTaskIds: string[], workspaceId?: string): TaskItem[];
+    getWorkstreamTaskOrderForSync(workstreamId: string, workspaceId?: string): string[];
     createTask(input: Partial<TaskItem>, options?: CreateTaskOptions): TaskItem;
+    private createTaskUnchecked;
+    private runWithWorkspaceSyncTaskCreateGuard;
+    hasTaskDeletionMarkerForSync(id: string, workspaceId?: string): boolean;
+    notifyDurableTaskCreateCommitted(workspaceId: string, taskId: string): void;
+    notifyDurableTaskBatchCommitted(workspaceId: string, taskIds: string[]): void;
+    notifyDurableInitiativeCommitted(workspaceId: string, _initiativeId: string): void;
+    notifyDurableWorkstreamCommitted(workspaceId: string, _workstreamId: string): void;
+    notifyDurableWorkflowRuntimeCommitted(workspaceId: string, _executionId: string): void;
+    installDurableInitiativeAuthoritativeForSync(initiative: InitiativeItem, workspaceId: string): InitiativeItem;
+    installDurableWorkstreamAuthoritativeForSync(workstream: WorkstreamItem, workspaceId: string): WorkstreamItem;
+    installDurableTaskCreateAuthoritativeForSync(task: TaskItem, workspaceId: string): TaskItem;
+    installWorkspaceSyncV3TaskRootAuthoritativeForSync(task: TaskItem, workspaceId: string): TaskItem;
     bulkCreateTasks(tasks: Array<Partial<TaskItem>>, options?: {
         atomic?: boolean;
         validateOnly?: boolean;
@@ -2095,6 +2375,16 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         allowClientProvidedId?: boolean;
         provisionalLocalReference?: boolean;
     }): BulkCreateTaskResult;
+    private runTaskMetadataOwnershipTransaction;
+    private runLegacyTaskMetadataMutation;
+    private runLegacyTaxonomyMutation;
+    private runLegacyTaskLifecycleMutation;
+    private runLegacyInitiativeMutation;
+    private runLegacyWorkstreamMutation;
+    private listWorkspaceTaskIdsForMetadataBoundary;
+    private assertNoProtectedTaskMetadata;
+    private assertNoProtectedTaskTaxonomy;
+    private assertNoProtectedTaskLifecycle;
     updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
         persistBackup?: boolean;
         preferIncomingReferenceNumberOnConflict?: boolean;
@@ -2102,21 +2392,124 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         syncUpdatedAt?: string;
         actorRef?: string;
         skipTaskEvents?: boolean;
+        taskEventId?: string;
+        taskEventAction?: string;
+        taskEventDetails?: Record<string, unknown>;
+        allowAuthoritativeTaskEventReplacement?: boolean;
         saveSource?: 'manual' | 'autosave';
+        emitRealtime?: boolean;
+        allowV3OwnedMetadataWrite?: boolean;
+        allowV3OwnedLifecycleWrite?: boolean;
+        allowArchivedNestedContentSyncWrite?: boolean;
+        preferExplicitAttachmentRole?: boolean;
+        preferExplicitAttachmentAssetId?: boolean;
     }): TaskItem | null;
+    notifyDurableTaskMetadataCommitted(workspaceId: string, taskId: string): void;
     addComment(id: string, text: string, author: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
         actorRef?: string;
         skipTaskEvents?: boolean;
     }): TaskItem | null;
+    private addPlanningEntityComment;
+    addInitiativeComment(id: string, text: string, author: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        actorRef?: string;
+        skipEntityEvents?: boolean;
+    }): InitiativeItem | null;
+    appendInitiativeCommentForDurableSync(input: {
+        initiativeId: string;
+        workspaceId: string;
+        comment: Comment;
+        updatedAt: string;
+        actorRef: string;
+        entityEventId: string;
+    }): InitiativeItem;
+    addWorkstreamComment(id: string, text: string, author: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        actorRef?: string;
+        skipEntityEvents?: boolean;
+    }): WorkstreamItem | null;
+    appendWorkstreamCommentForDurableSync(input: {
+        workstreamId: string;
+        workspaceId: string;
+        comment: Comment;
+        updatedAt: string;
+        actorRef: string;
+        entityEventId: string;
+    }): WorkstreamItem;
+    private normalizeTaskRelationship;
+    private mapTaskRelationshipRow;
+    private buildTaskRelationshipId;
+    resolveTaskRelationshipIdentity(sourceTaskId: string, targetTaskId: string, type: TaskRelationshipInputType, workspaceId?: string): {
+        id: string;
+        sourceTaskId: string;
+        targetTaskId: string;
+        kind: TaskRelationshipKind;
+    };
+    private taskRelationshipWouldCycle;
+    listTaskRelationships(taskId: string, workspaceId?: string, options?: {
+        type?: TaskRelationshipInputType;
+        direction?: 'incoming' | 'outgoing' | 'both';
+        includeDeleted?: boolean;
+    }): TaskRelationshipRecord[];
+    getTaskRelationshipCounts(taskId: string, workspaceId?: string): {
+        dependsOnCount: number;
+        blocksCount: number;
+        relatedCount: number;
+        supersedesCount: number;
+        supersededByCount: number;
+    };
+    lockTaskRelationshipMutationDomain(workspaceId?: string, updatedAt?: string): void;
+    lockTaskLifecycleMutationDomain(workspaceId?: string, updatedAt?: string): void;
+    linkTaskRelationship(sourceTaskId: string, targetTaskId: string, type: TaskRelationshipInputType, workspaceId?: string, actorRef?: string, options?: {
+        persistBackup?: boolean;
+        updatedAt?: string;
+    }): {
+        relationship: TaskRelationshipRecord;
+        outcome: 'created' | 'existing' | 'reactivated';
+    };
+    unlinkTaskRelationship(sourceTaskId: string, targetTaskId: string, type: TaskRelationshipInputType, workspaceId?: string, actorRef?: string, options?: {
+        persistBackup?: boolean;
+        updatedAt?: string;
+    }): {
+        relationship: TaskRelationshipRecord | null;
+        outcome: 'removed' | 'already_absent';
+    };
+    notifyDurableTaskRelationshipCommitted(workspaceId: string, relationship: TaskRelationshipRecord, changeType: 'upsert' | 'delete'): void;
+    listTaskRelationshipsForSync(workspaceId?: string, cursor?: {
+        watermark: string;
+        id: string;
+    } | null, limit?: number): TaskRelationshipRecord[];
+    applyTaskRelationshipForSync(incoming: TaskRelationshipRecord, workspaceId?: string): 'applied' | 'skipped';
+    installDurableTaskRelationshipAuthoritativeForSync(incoming: TaskRelationshipRecord, workspaceId?: string): 'applied';
+    private applyTaskRelationshipForSyncWithPolicy;
+    getTaskRelationshipForSync(id: string, workspaceId?: string): TaskRelationshipRecord | null;
+    private tombstoneTaskRelationships;
     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;
+        emitRealtime?: boolean;
+        deletedAt?: string;
+        actor?: string;
+        actorType?: 'human' | 'ai' | 'system';
+        source?: DeletedTaskSource;
+        details?: DeletedTaskDetails;
     }): boolean;
+    installDurableTaskDeleteAuthoritativeForSync(input: {
+        taskId: string;
+        deletedAt: string;
+        relationships: TaskRelationshipRecord[];
+    }, workspaceId?: string): DeletedTaskRecord;
+    notifyDurableTaskDeleteCommitted(workspaceId: string, taskId: string): void;
     restoreDeletedTask(id: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        emitRealtime?: boolean;
         actorRef?: string;
+        syncUpdatedAt?: string;
+        taskEventId?: string;
+        allowV3OwnedDeleteRestore?: boolean;
+        restoreDestination?: TaskRestoreDestination;
     }): TaskItem | null;
     listWorkspaceSyncDeletes(workspaceId?: string): Array<{
         taskId: string;
@@ -2129,40 +2522,112 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         task: any;
         archived: boolean;
     }>;
+    /**
+     * Full task inventory for authoritative repair without the per-task UI
+     * hydration performed by rowToTask. Repair serializes task roots, comments,
+     * and checklist items separately; task activity, actor decoration, and
+     * resolved attachment bodies are not part of that canonical inventory.
+     */
+    listTasksForAuthoritativeRepair(workspaceId: string): TaskItem[];
     listWorkspaceSyncDeletesSince(workspaceId: string | undefined, cursor: {
         watermark: string;
         id: string;
-    } | null, limit: number): Array<{
-        taskId: string;
-        deletedAt: string;
-    }>;
+    } | null, limit: number): WorkspaceSyncTaskDeleteRecord[];
     archiveTask(id: string, isCancellation?: boolean, reason?: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        emitRealtime?: boolean;
         skipRecompute?: boolean;
         syncUpdatedAt?: string;
         skipHierarchyCheck?: boolean;
         actorRef?: string;
         skipTaskEvents?: boolean;
+        taskEventId?: string;
+        allowV3OwnedLifecycleWrite?: boolean;
     }): TaskItem | null;
+    reopenTask(id: string, workspaceId?: string, options?: {
+        actorRef?: string;
+        assignee?: string | null;
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        syncUpdatedAt?: string;
+        allowV3OwnedMetadataWrite?: boolean;
+        allowV3OwnedLifecycleWrite?: boolean;
+        taskEventId?: string;
+    }): {
+        task: TaskItem;
+        previousStatus: string;
+        previousArchived: boolean;
+        previousAssignee: string | null;
+        reopened: boolean;
+        claimed: boolean;
+        statusChanged: boolean;
+    };
     unarchiveTask(id: string, workspaceId?: string, options?: {
         persistBackup?: boolean;
+        emitRealtime?: boolean;
         skipRecompute?: boolean;
         syncUpdatedAt?: string;
         actorRef?: string;
         skipTaskEvents?: boolean;
+        taskEventId?: string;
+        allowV3OwnedLifecycleWrite?: boolean;
     }): TaskItem | null;
+    installDurableTaskLifecycleAuthoritativeForSync(task: TaskItem, mutationKind: 'archive' | 'unarchive' | 'complete' | 'reopen', workspaceId: string): TaskItem;
+    installDurableTaskStatusAuthoritativeForSync(task: TaskItem, payload: DurableTaskStatusMutationPayload, installAssignee: boolean, workspaceId: string): TaskItem;
+    addTaskStatusEventsForDurableSync(event: {
+        taskId: string;
+        workspaceId: string;
+        action: string;
+        actor: string;
+        eventId: string;
+        createdAt: string;
+        details: {
+            changes: Record<string, {
+                from: unknown;
+                to: unknown;
+            }>;
+        };
+        task: TaskItem;
+        previousWorkstreamId: string | null;
+        allowAuthoritativeReplacement?: boolean;
+    }): void;
+    addTaskCommentEventForDurableSync(event: {
+        taskId: string;
+        workspaceId: string;
+        actor: string;
+        eventId: string;
+        createdAt: string;
+        comment: Comment;
+    }): void;
+    reconcileDurableTaskStatusMembershipEventsForSync(input: {
+        task: TaskItem;
+        workspaceId: string;
+        primaryEventId: string;
+        activity: TaskEvent | null;
+    }): boolean;
+    notifyDurableTaskLifecycleCommitted(workspaceId: string, taskId: string): void;
     bulkArchive(ids: string[], isCancellation?: boolean, workspaceId?: string): number;
     applyWorkspaceSyncSnapshot(input: {
         tasks?: Array<Partial<TaskItem>>;
         archived?: Array<Partial<TaskItem>>;
-    }, workspaceId?: string): {
+    }, workspaceId?: string, options?: {
+        deferSideEffects?: boolean;
+        authoritativeTaskTaxonomyIds?: ReadonlySet<string>;
+        authoritativeTaskNestedContentIds?: ReadonlySet<string>;
+    }): {
         total: number;
         created: number;
         updated: number;
         archived: number;
         unarchived: number;
         skipped: number;
+        changedTaskIds?: string[];
     };
+    notifyWorkspaceSyncSnapshotCommitted(workspaceId: string, taskIds: string[]): void;
+    notifyWorkspaceSyncV3TaskRootsCommitted(workspaceId: string, input: {
+        upsertIds: string[];
+        deleteIds: string[];
+    }): 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: {
@@ -2170,8 +2635,13 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         patch: Record<string, unknown>;
     }): Record<string, unknown>;
     readPushIdempotency(workspaceId: string, idempotencyKey: string): string | null;
+    claimPushIdempotency(workspaceId: string, idempotencyKey: string, claimToken: string): import("./SyncReconciliationService.js").PushIdempotencyClaimResult;
+    completePushIdempotencyClaim(workspaceId: string, idempotencyKey: string, claimToken: string, payload: string): boolean;
+    releasePushIdempotencyClaim(workspaceId: string, idempotencyKey: string, claimToken: string): void;
+    renewPushIdempotencyClaim(workspaceId: string, idempotencyKey: string, claimToken: string): boolean;
     writePushIdempotency(workspaceId: string, idempotencyKey: string, payload: string): void;
     recordSyncEvent(workspaceId: string, event: SyncEventInput): void;
+    recordSyncEventDurably(workspaceId: string, event: SyncEventInput): void;
     listSyncEvents(workspaceId: string, limit?: number): Array<{
         id: number;
         eventType: string;
@@ -2198,7 +2668,9 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
      * record the updatedAt is NOT advanced — only a new or changed hash triggers an update.
      */
     upsertDocumentWatermark(workspaceId: string, docPath: string, contentHash: string, updatedAt: string): void;
+    upsertDocumentWatermarkStrict(workspaceId: string, docPath: string, contentHash: string, updatedAt: string): void;
     deleteDocumentWatermark(workspaceId: string, docPath: string): void;
+    deleteDocumentWatermarkStrict(workspaceId: string, docPath: string): void;
     notifyDocumentMetadataMutation(workspaceId: string, entityIds: string[], changeType?: 'upsert' | 'delete'): void;
     getCategories(workspaceId?: string): CategoryConfig[];
     getTaxonomyState(workspaceId?: string): WorkspaceTaxonomyState;
@@ -2229,6 +2701,23 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         updatedAt: string;
     };
     updateTaxonomyState(taxonomyState: WorkspaceTaxonomyState, workspaceId?: string): WorkspaceTaxonomyState;
+    /** Caller must already hold the taxonomy v2/v3 coexistence boundary. */
+    replaceTaxonomyStateForLegacySync(taxonomyState: WorkspaceTaxonomyState, workspaceId?: string): WorkspaceTaxonomyState;
+    notifyTaxonomyStateForLegacySync(workspaceId?: string): void;
+    listTaskIdsIncompatibleWithTaxonomyStateForSync(taxonomyState: NormalizedWorkspaceTaxonomyState, workspaceId?: string): string[];
+    replaceTaxonomyStateForDurableSync(input: {
+        workspaceId: string;
+        taxonomyState: NormalizedWorkspaceTaxonomyState;
+        updatedAt: string;
+    }): NormalizedWorkspaceTaxonomyState;
+    applyTaskTaxonomyRemapForDurableSync(input: {
+        workspaceId: string;
+        taskId: string;
+        patch: Partial<Pick<TaskItem, 'category' | 'type' | 'priority'>>;
+        updatedAt: string;
+    }): TaskItem;
+    notifyDurableTaxonomyCommitted(workspaceId: string): void;
+    notifyDurableTaxonomyCompositeCommitted(workspaceId: string, taskIds: string[]): void;
     updateTaxonomies(taxonomies: any[], workspaceId?: string): void;
     getPriorities(workspaceId?: string): Array<{
         value: number;
@@ -2242,20 +2731,20 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         color?: string;
         icon?: string;
     }>, workspaceId?: string): void;
-    getApproaches(): Array<{
-        value: string;
-        label: string;
-        color?: string;
-        icon?: string;
-    }>;
-    updateApproaches(approaches: Array<{
-        value: string;
-        label: string;
-        color?: string;
-        icon?: string;
-    }>): void;
     private renderChecklistBlocks;
     getInitiativeTemplates(): InitiativeTemplate[];
+    buildInitiativeTemplateTaskInputs(input: {
+        templateId: string;
+        title: string;
+        description?: string;
+        category?: string;
+        type?: string;
+        priority?: number;
+        createdBy?: string;
+    }, workspaceId?: string): {
+        tasks: Array<Partial<TaskItem>>;
+        templateId: string;
+    };
     createInitiativeFromTemplate(input: {
         templateId: string;
         title: string;
@@ -2263,7 +2752,6 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         category?: string;
         type?: string;
         priority?: number;
-        approach?: string;
         createdBy?: string;
     }, workspaceId?: string): {
         initiative: TaskItem;
@@ -2290,12 +2778,6 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
             fields: string[];
         }>;
     };
-    exportResources(type: string, destinationRelativePath: string, variables?: Record<string, string>, environment?: string): number;
-    exportWorkflows(environment: string, workflowNames?: string[], variables?: any): number;
-    listWorkflowTemplates(): any[];
-    getWorkflowTemplate(name: string): any;
-    listWorkflowOverrideNames(): string[];
-    listEnvironments(): any[];
     /**
      * Persists a stable JSON backup of all tasks and archives if specified by environment.
      * This allows for Git versioning of the database content.