@taskforcehq/taskforce 0.3.168

package/dist/core/Taskforce.d.ts

@@ -0,0 +1,1063 @@
+import type { DatabaseAdapter, DatabaseProvider } from '../storage/databaseAdapter.js';
+/**
+ * Taskforce Core Logic
+ *
+ * Handles all data persistence and business logic for managing tasks.
+ * Uses a storage adapter layer for database access.
+ */
+export interface Comment {
+    id: string;
+    author: string;
+    text: string;
+    timestamp: string;
+}
+export type TaskStatus = 'task' | 'on-hold' | 'in-progress' | 'review' | 'done' | 'cancelled';
+export type TaskAssignee = 'unassigned' | 'agent' | 'user';
+export interface TaskItem {
+    id: string;
+    title: string;
+    description: string | null;
+    category: string;
+    type: string;
+    priority: number;
+    complexity: number;
+    status: TaskStatus;
+    approach?: string;
+    createdAt: string;
+    updatedAt?: string;
+    completedAt?: string | null;
+    /** @deprecated */
+    inProgress?: boolean;
+    /** @deprecated */
+    readyForReview?: boolean;
+    comments?: Comment[];
+    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 */
+    completed?: boolean;
+    /** @deprecated */
+    cancelled?: boolean;
+    taxonomies?: Record<string, string | string[]>;
+    createdBy?: string;
+    assignee?: TaskAssignee;
+    canceledReason?: string;
+    isArchived?: boolean;
+    scheduledDate?: string | null;
+    dueDate?: string | null;
+    scheduledWeekKey?: string | null;
+    orderInDay?: number | null;
+    parentTaskId?: string | null;
+    childDisplayOrder?: number | null;
+}
+export interface TaskWarning {
+    code: string;
+    severity: 'warning';
+    title: string;
+    message: string;
+    requiresConfirmation: boolean;
+}
+export interface ScheduleBoardColumns {
+    backlog: TaskItem[];
+    expired: TaskItem[];
+    mon: TaskItem[];
+    tue: TaskItem[];
+    wed: TaskItem[];
+    thu: TaskItem[];
+    fri: TaskItem[];
+    sat?: TaskItem[];
+    sun?: TaskItem[];
+}
+export interface ScheduleBoardResult {
+    week: string;
+    columns: ScheduleBoardColumns;
+    meta: {
+        showWeekends: boolean;
+        capacityWarnings: Array<{
+            date: string;
+            level: 'soft';
+        }>;
+    };
+}
+export type RealtimeMutationEntityType = 'task' | 'taxonomy' | 'document-metadata';
+export interface RealtimeMutationEvent {
+    eventId: string;
+    workspaceId: string;
+    cursor: string;
+    serverEpoch: string;
+    seq: number;
+    entityType: RealtimeMutationEntityType;
+    changeType: string;
+    entityIds: string[];
+    dataVersion: number;
+    serverTs: string;
+}
+export declare class TaskforceRuleError extends Error {
+    statusCode: number;
+    code: string;
+    details?: unknown;
+    constructor(message: string, statusCode?: number, code?: string, details?: unknown);
+}
+export interface CategoryConfig {
+    value: string;
+    label: string;
+    path?: string;
+    paths?: string[];
+    specialistFile?: string;
+    icon?: string;
+    color?: string;
+    disabled?: boolean;
+}
+export interface TaskforceConfig {
+    projectRoot: string;
+    storagePath?: string;
+    tenantId?: string;
+    database?: {
+        provider?: DatabaseProvider;
+        connectionString?: string;
+    };
+}
+export interface TaskFile {
+    tasks: TaskItem[];
+    config?: {
+        categories?: Array<string | CategoryConfig>;
+        types?: Array<{
+            value: string;
+            label: string;
+        }>;
+        priorities?: Array<{
+            value: number;
+            label: string;
+            color?: string;
+            icon?: string;
+        }>;
+        complexities?: Array<{
+            value: number;
+            label: string;
+            color?: string;
+            icon?: string;
+        }>;
+        approaches?: Array<{
+            value: string;
+            label: string;
+            color?: string;
+            icon?: string;
+        }>;
+        theme?: 'dark' | 'light' | 'midnight';
+        shortcut?: string;
+        jsonBackupEnabled?: boolean;
+        taxonomies?: any[];
+        assigneeFilterEnabled?: boolean;
+    };
+}
+export interface ArchiveFile {
+    archived: TaskItem[];
+}
+export interface BulkCreateTaskError {
+    index: number;
+    message: string;
+    statusCode?: number;
+    code?: string;
+    details?: unknown;
+}
+export interface BulkCreateTaskResult {
+    created: TaskItem[];
+    errors: BulkCreateTaskError[];
+    total: number;
+    atomic: boolean;
+    validateOnly: boolean;
+}
+export interface BulkUpdateFieldsPreviewItem {
+    id: string;
+    index: number;
+    fields: Record<string, any>;
+    changedFields: string[];
+}
+export interface BulkUpdateFieldsPreviewSkipped {
+    index: number;
+    id?: string;
+    message: string;
+    statusCode: number;
+    code: string;
+}
+export interface BulkUpdateFieldsPreview {
+    total: number;
+    deduped: number;
+    toApply: BulkUpdateFieldsPreviewItem[];
+    skipped: BulkUpdateFieldsPreviewSkipped[];
+    byField: Record<string, number>;
+    priorityBefore?: Record<number, number>;
+    priorityAfter?: Record<number, number>;
+}
+export interface InitiativeTemplateMilestone {
+    title: string;
+    description: string;
+    priority?: number;
+    approach?: string;
+    category?: string;
+}
+export interface InitiativeTemplate {
+    id: string;
+    name: string;
+    description: string;
+    checklistBlocks: {
+        definitionOfDone: string[];
+        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 AccessRole = 'owner' | 'admin' | 'member' | 'read-only';
+export type SystemRole = 'system_admin' | 'user';
+type PermissionMode = 'read-only' | 'read-write';
+interface UserAccessRecord {
+    userId: string;
+    workspaceId: string;
+    role: AccessRole;
+    permissionMode: PermissionMode;
+    disabled: boolean;
+    betaAccess: boolean;
+}
+interface UserIdentityRecord {
+    userId: string;
+    email: string;
+    systemRole?: SystemRole;
+    betaAccess?: boolean;
+}
+interface WorkspaceUserRecord {
+    userId: string;
+    email: string;
+    displayName?: string | null;
+    role: AccessRole;
+    permissionMode: PermissionMode;
+    betaAccess: boolean;
+    status: string;
+    disabled: boolean;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    emailVerifiedAt?: string | null;
+}
+interface SystemUserRecord {
+    userId: string;
+    email: string;
+    displayName?: string | null;
+    systemRole: SystemRole;
+    betaAccess: boolean;
+    disabled: boolean;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    emailVerifiedAt?: string | null;
+}
+export type SetupState = 'present' | 'missing' | 'unreadable';
+export type RuntimeMode = 'local' | 'cloud';
+export type WorkspaceMode = 'core' | 'operations';
+export interface WorkspaceProfileRecord {
+    id: string;
+    slug?: string | null;
+    name: string;
+    description?: string | null;
+}
+export interface UserWorkspaceRecord {
+    id: string;
+    slug?: string | null;
+    name: string;
+    description?: string | null;
+    role: AccessRole;
+    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;
+    runtimeMode: RuntimeMode;
+    workspaceId: string;
+    mode: WorkspaceMode;
+    forceSetup: boolean;
+    forceGlobalSetup: boolean;
+    forceWorkspaceSetup: boolean;
+    workspace?: WorkspaceProfileRecord | null;
+    suggestedWorkspaceName?: string;
+}
+interface WorkspaceProfileUpdateInput {
+    name: string;
+    description?: string | null;
+    slug?: string | null;
+}
+interface CreateTaskOptions {
+    persistBackup?: boolean;
+    workspaceId?: string;
+    allowClientProvidedId?: boolean;
+}
+interface AdminAuditLogRecord {
+    id: string;
+    ts: string;
+    action: string;
+    actorUserId: string;
+    actorRole: string;
+    workspaceId: string;
+    details: Record<string, unknown>;
+}
+export type EntitlementState = 'active' | 'trialing' | 'grace' | 'suspended' | 'canceled';
+export type PlanFeatureAccess = 'enabled' | 'disabled' | 'limited';
+export interface PlanFeatureSnapshot {
+    featureKey: string;
+    access: PlanFeatureAccess;
+    config: Record<string, unknown>;
+}
+export interface PlanVersionSnapshot {
+    planVersionId: string;
+    planId: string;
+    versionNumber: number;
+    isDefault: boolean;
+    seatLimit: number | null;
+    metadata: Record<string, unknown>;
+    features: Record<string, PlanFeatureSnapshot>;
+}
+export interface PlanCatalogSnapshot {
+    planId: string;
+    displayName: string;
+    status: 'active' | 'archived';
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AccountEntitlementSnapshot {
+    accountId: string;
+    planVersionId: string;
+    planId: string;
+    state: EntitlementState;
+    effectiveAt: string | null;
+    effectiveUntil: string | null;
+    version: PlanVersionSnapshot;
+}
+export interface SeatUsageSnapshot {
+    used: number;
+    limit: number | null;
+    remaining: number | null;
+}
+export interface FeatureEvaluationResult {
+    allowed: boolean;
+    reasonCode: string;
+    state: EntitlementState;
+    seatUsage?: SeatUsageSnapshot;
+    feature?: PlanFeatureSnapshot;
+}
+interface PasswordAuthResult {
+    ok: boolean;
+    access?: {
+        userId: string;
+        workspaceId: string;
+        role: AccessRole;
+    };
+    code?: 'INVALID_CREDENTIALS' | 'EMAIL_NOT_VERIFIED';
+}
+export declare class TaskforceCore {
+    private static readonly DEFAULT_CATEGORY_VALUE;
+    private static readonly DEFAULT_APPROACH_VALUE;
+    private projectRoot;
+    private basePath;
+    private dbPath;
+    private configFile;
+    private globalSettingsDbPath;
+    private screenshotsDir;
+    private contextFilesDir;
+    private taskDataDir;
+    private tenantId;
+    private db;
+    private globalSettingsDb;
+    private realtimeMutationListeners;
+    private readonly realtimeServerEpoch;
+    private realtimeMutationSeq;
+    private emitRealtimeMutation;
+    onRealtimeMutation(listener: (event: RealtimeMutationEvent) => void): () => void;
+    private normalizePriorityValue;
+    private normalizePriorityDefinitions;
+    private migratePriorityScaleIfNeeded;
+    private migrateOnHoldPriorityToStatusIfNeeded;
+    private healPriorityConfigIfNeeded;
+    private estimateComplexity;
+    private isAiCreated;
+    private normalizeCommentAuthor;
+    private normalizeTaxonomyToken;
+    private normalizeStatusValue;
+    private sanitizeAssignee;
+    private inferAssigneeFromOwnerHints;
+    private resolveTaxonomyValue;
+    private enforceCreateTaskTaxonomy;
+    private sanitizeParentTaskId;
+    private sanitizeChildDisplayOrder;
+    private sanitizeDateOnly;
+    private sanitizeOrderInDay;
+    private formatDateOnlyUtc;
+    private parseDateOnlyUtc;
+    private dateOnlyToIsoWeekKey;
+    private parseIsoWeekKeyToDates;
+    private todayDateOnlyLocal;
+    private normalizeWorkspaceId;
+    private buildSchedulingWarnings;
+    private nextChildDisplayOrder;
+    private taskExists;
+    private valueEqualsForBulkUpdate;
+    private hasNonTerminalDirectChildren;
+    private hasDirectChildren;
+    private getTaskHierarchyRows;
+    private buildTaskHierarchyIndex;
+    private getDescendantIds;
+    private hasOpenDescendants;
+    private recomputeTaskAndAncestorCompletionFromDescendants;
+    private createsParentCycle;
+    private assertParentLinkAllowed;
+    constructor(config: TaskforceConfig);
+    close(): void;
+    getDatabaseAdapter(): DatabaseAdapter;
+    getTenantId(): string;
+    private parseJsonObject;
+    private normalizeEntitlementState;
+    private normalizeFeatureAccess;
+    private isEntitlementStateAllowed;
+    private ensureDefaultPlanCatalog;
+    private resolvePlanVersionIdForTier;
+    private resolveEntitlementStateForBillingValue;
+    private ensureAccountEntitlementRecord;
+    private backfillAccountEntitlements;
+    createUserBillingRecord(userId: string): void;
+    getUserEntitlement(userId: string): {
+        entitlementState: string;
+        tier: string;
+    };
+    getEffectivePlanVersion(accountId: string): PlanVersionSnapshot;
+    getAccountEntitlement(accountId: string): AccountEntitlementSnapshot;
+    countWorkspaceSeatUsage(workspaceId: string, options?: {
+        includeInvited?: boolean;
+    }): SeatUsageSnapshot;
+    assertSeatAvailable(workspaceId: string): void;
+    evaluateFeatureAccess(input: {
+        userId: string;
+        workspaceId: string;
+        featureKey: string;
+        action?: string;
+        context?: Record<string, unknown>;
+    }): FeatureEvaluationResult;
+    getUserAccountPlanMode(userId: string): 'personal' | 'team';
+    setUserAccountPlanMode(userId: string, mode: 'personal' | 'team'): 'personal' | 'team';
+    private ensureDirectories;
+    private migrateLegacyGlobalSettingsDbIfNeeded;
+    private initializeSchema;
+    private performMigrationIfNeeded;
+    private migrateSystemRoleBackfillIfNeeded;
+    private migrateUserBetaAccessBackfillIfNeeded;
+    private getWorkspaceOwnerUserId;
+    getWorkspacePlanMode(workspaceId: string): 'personal' | 'team';
+    setWorkspacePlanMode(workspaceId: string, mode: 'personal' | 'team', source?: string): 'personal' | 'team';
+    private readConfig;
+    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;
+    updateGlobalSettings(settings: GlobalTaskforceSettings): void;
+    private sanitizeUserGlobalSyncSettings;
+    getUserGlobalSyncSettings(userId: string): {
+        settings: UserGlobalSyncSettings;
+        updatedAt: string | null;
+    };
+    upsertUserGlobalSyncSettings(userId: string, settings: unknown, updatedAt?: string | null): {
+        settings: UserGlobalSyncSettings;
+        updatedAt: string;
+        applied: boolean;
+    };
+    getJsonBackupEnabled(): boolean;
+    private rowToTask;
+    private generateId;
+    private generateEntityId;
+    private detectDefaultLocalWorkspaceName;
+    private normalizeWorkspaceMode;
+    private humanizeWorkspaceIdentifier;
+    private backfillWorkspaceProfilesForCompatibility;
+    private isPlaceholderWorkspaceName;
+    private normalizeWorkspaceSlug;
+    private createWorkspaceRecord;
+    createWorkspace(input: {
+        workspaceId?: string | null;
+        name: string;
+        description?: string | null;
+        slug?: string | null;
+    }): WorkspaceProfileRecord;
+    getWorkspaceProfile(workspaceId: string): WorkspaceProfileRecord | null;
+    listUserWorkspaces(userId: string): UserWorkspaceRecord[];
+    createWorkspaceForUser(input: {
+        userId: string;
+        name: string;
+        description?: string | null;
+        role?: AccessRole;
+        preferredWorkspaceId?: string;
+    }): UserWorkspaceRecord;
+    deleteWorkspace(input: {
+        workspaceId: string;
+    }): WorkspaceDeleteSummary;
+    updateWorkspaceProfile(workspaceId: string, input: WorkspaceProfileUpdateInput): WorkspaceProfileRecord;
+    getSetupState(workspaceId: string, runtimeMode?: RuntimeMode): SetupStateSnapshot;
+    getPaths(): {
+        projectRoot: string;
+        projectName: string;
+        tenantId: string;
+        basePath: string;
+        taskDataDir: string;
+        screenshotsDir: string;
+        contextFilesDir: string;
+        mcpScript: string;
+    };
+    workspaceExists(workspaceId: string): boolean;
+    resolvePreferredWorkspaceId(options?: {
+        allowDefault?: boolean;
+    }): string | null;
+    resolvePreferredUserWorkspaceId(userId: string, options?: {
+        preferredWorkspaceId?: string | null;
+        persistedWorkspaceId?: string | null;
+    }): string | null;
+    listTasks(workspaceId?: string): TaskFile;
+    getDataVersion(): number;
+    getDatabaseProvider(): DatabaseProvider;
+    isDatabaseHealthy(): boolean;
+    listArchive(workspaceId?: string): ArchiveFile;
+    getStats(workspaceId?: string): {
+        active: {
+            total: number;
+            byStatus: Record<string, number>;
+            byPriority: Record<number, number>;
+        };
+        archived: {
+            total: number;
+            doneCount: number;
+            cancelledCount: number;
+        };
+    };
+    private normalizeAccessRole;
+    private normalizeSystemRole;
+    private normalizePermissionMode;
+    ensureBootstrapUserAccess(input: {
+        userId: string;
+        workspaceId: string;
+        role: AccessRole;
+        email?: string;
+        displayName?: string;
+    }): UserAccessRecord;
+    resolveUserAccess(userId: string, workspaceId: string, fallbackRole?: AccessRole): UserAccessRecord | null;
+    resolveUserIdentity(userId: string): UserIdentityRecord | null;
+    getSystemRole(userId: string): SystemRole;
+    getUserBetaAccess(userId: string): boolean;
+    countSystemAdmins(): number;
+    hasAnySystemAdmin(): boolean;
+    listSystemUsers(): SystemUserRecord[];
+    setSystemRole(userId: string, role: SystemRole): boolean;
+    setUserDisabledGlobal(userId: string, disabled: boolean): boolean;
+    setUserBetaAccessGlobal(userId: string, enabled: boolean): boolean;
+    listWorkspaceUsers(workspaceId: string): WorkspaceUserRecord[];
+    addAdminAuditLog(input: {
+        action: string;
+        actorUserId: string;
+        actorRole: string;
+        workspaceId: string;
+        details?: Record<string, unknown>;
+    }): void;
+    listAdminAuditLogs(workspaceId: string, limit?: number, offset?: number): AdminAuditLogRecord[];
+    countAdminAuditLogs(workspaceId: string): number;
+    private isValidEntitlementTransition;
+    addEntitlementAuditLog(input: {
+        actorUserId: string;
+        actorRole: string;
+        accountId: string;
+        action: string;
+        reason?: string;
+        before?: unknown;
+        after?: unknown;
+        requestId?: string;
+    }): void;
+    upsertPlanCatalog(input: {
+        planId: string;
+        displayName: string;
+        status?: 'active' | 'archived';
+    }): {
+        planId: string;
+        displayName: string;
+        status: 'active' | 'archived';
+    };
+    listPlanCatalog(): PlanCatalogSnapshot[];
+    listPlanVersions(planId: string): PlanVersionSnapshot[];
+    getPlanVersionFeatures(planId: string, versionId: string): PlanVersionSnapshot;
+    searchAccountsByEmail(query: string, limit?: number): Array<{
+        accountId: string;
+        email: string;
+        displayName: string | null;
+        disabled: boolean;
+    }>;
+    createPlanVersion(input: {
+        planId: string;
+        versionNumber: number;
+        isDefault?: boolean;
+        seatLimit?: number | null;
+        metadata?: Record<string, unknown>;
+    }): PlanVersionSnapshot;
+    private getPlanVersionSnapshot;
+    updatePlanVersionFeatures(input: {
+        planVersionId: string;
+        features: Array<{
+            featureKey: string;
+            access: PlanFeatureAccess;
+            config?: Record<string, unknown>;
+        }>;
+    }): PlanVersionSnapshot;
+    updateAccountEntitlement(input: {
+        accountId: string;
+        planVersionId?: string;
+        entitlementState?: EntitlementState;
+        effectiveAt?: string | null;
+        effectiveUntil?: string | null;
+        actorUserId: string;
+        actorRole: string;
+        reason?: string;
+        requestId?: string;
+    }): AccountEntitlementSnapshot;
+    listEntitlementAuditLog(accountId: string, limit?: number, offset?: number): Array<{
+        id: string;
+        accountId: string;
+        action: string;
+        actorUserId: string;
+        actorRole: string;
+        reason: string | null;
+        before: Record<string, unknown>;
+        after: Record<string, unknown>;
+        createdAt: string;
+    }>;
+    getAccountEntitlementsPayload(input: {
+        userId: string;
+        workspaceId: string;
+    }): {
+        accountId: string;
+        workspaceId: string;
+        planId: string;
+        planVersionId: string;
+        state: EntitlementState;
+        effectiveAt: string | null;
+        effectiveUntil: string | null;
+        seatUsage: SeatUsageSnapshot;
+        features: Record<string, {
+            allowed: boolean;
+            access: PlanFeatureAccess;
+            config: Record<string, unknown>;
+        }>;
+    };
+    inviteWorkspaceUser(input: {
+        workspaceId: string;
+        email: string;
+        displayName?: string;
+        role?: AccessRole;
+        betaAccess?: boolean;
+    }): WorkspaceUserRecord;
+    setWorkspaceUserDisabled(userId: string, workspaceId: string, disabled: boolean): boolean;
+    setWorkspaceUserBetaAccess(userId: string, workspaceId: string, enabled: boolean): boolean;
+    hasWorkspaceAdmin(workspaceId: string): boolean;
+    countWorkspaceOwners(workspaceId: string): number;
+    setWorkspaceUserPermissionMode(userId: string, workspaceId: string, mode: PermissionMode): boolean;
+    removeWorkspaceUser(userId: string, workspaceId: string): boolean;
+    transferWorkspaceOwnership(input: {
+        workspaceId: string;
+        fromUserId: string;
+        toUserId: string;
+    }): boolean;
+    ensurePasswordUser(input: {
+        email: string;
+        password: string;
+        workspaceId: string;
+        role?: AccessRole;
+        displayName?: string;
+        emailVerified?: boolean;
+        betaAccess?: boolean;
+    }): {
+        userId: string;
+        workspaceId: string;
+        role: AccessRole;
+    };
+    registerPasswordUser(input: {
+        email: string;
+        password: string;
+        workspaceId?: string;
+        role?: AccessRole;
+        displayName?: string;
+        betaAccess?: boolean;
+    }): {
+        userId: string;
+        workspaceId: string | null;
+        role: AccessRole;
+    };
+    private createOneTimeAuthToken;
+    private consumeOneTimeAuthToken;
+    private inspectOneTimeAuthToken;
+    isEmailVerified(email: string): boolean;
+    markEmailVerified(email: string): boolean;
+    requestEmailVerification(input: {
+        email: string;
+        ttlSeconds?: number;
+    }): {
+        token?: string;
+    };
+    verifyEmailWithToken(token: string): boolean;
+    requestPasswordReset(input: {
+        email: string;
+        ttlSeconds?: number;
+    }): {
+        token?: string;
+    };
+    requestInviteAcceptance(input: {
+        userId: string;
+        workspaceId: string;
+        ttlSeconds?: number;
+    }): {
+        token?: string;
+    };
+    revokeInviteAcceptanceForUser(userId: string): {
+        revoked: number;
+    };
+    inspectInviteAcceptance(token: string): {
+        state: 'valid' | 'expired' | 'used' | 'missing' | 'revoked';
+        email?: string;
+        userId?: string;
+        workspaceId?: string;
+    };
+    acceptInviteWithToken(input: {
+        token: string;
+        password: string;
+    }): {
+        userId: string;
+        email: string;
+        workspaceId: string;
+        role: AccessRole;
+    };
+    resetPasswordWithToken(input: {
+        token: string;
+        password: string;
+    }): boolean;
+    authenticatePasswordUserDetailed(input: {
+        email: string;
+        password: string;
+        workspaceId: string;
+        fallbackRole?: AccessRole;
+        requireVerifiedEmail?: boolean;
+    }): PasswordAuthResult;
+    authenticatePasswordUser(input: {
+        email: string;
+        password: string;
+        workspaceId: string;
+        fallbackRole?: AccessRole;
+    }): {
+        userId: string;
+        workspaceId: string;
+        role: AccessRole;
+    } | null;
+    updateWorkspaceUserRole(userId: string, workspaceId: string, role: AccessRole): boolean;
+    getTask(id: string, workspaceId?: string): TaskItem | null;
+    getScheduleBoard(weekKey: string, showWeekends?: boolean, workspaceId?: string): ScheduleBoardResult;
+    updateTaskSchedule(id: string, input: {
+        scheduledDate: string | null;
+        orderInDay?: number | null;
+    }, workspaceId?: string): {
+        task: TaskItem;
+        warnings: TaskWarning[];
+    } | null;
+    reorderScheduledTasks(moves: Array<{
+        id: string;
+        scheduledDate: string | null;
+        orderInDay?: number | null;
+    }>, workspaceId?: string): {
+        tasks: TaskItem[];
+        warnings: TaskWarning[];
+    };
+    createTask(input: Partial<TaskItem>, options?: CreateTaskOptions): TaskItem;
+    bulkCreateTasks(tasks: Array<Partial<TaskItem>>, options?: {
+        atomic?: boolean;
+        validateOnly?: boolean;
+        workspaceId?: string;
+        allowClientProvidedId?: boolean;
+    }): BulkCreateTaskResult;
+    updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+    }): TaskItem | null;
+    addComment(id: string, text: string, author: string, workspaceId?: string): TaskItem | null;
+    deleteTask(id: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+    }): boolean;
+    deleteTaskForSync(id: string, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+    }): boolean;
+    listWorkspaceSyncDeletes(workspaceId?: string): Array<{
+        taskId: string;
+        deletedAt: string;
+    }>;
+    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;
+    }>;
+    archiveTask(id: string, isCancellation?: boolean, reason?: string, workspaceId?: string, options?: {
+        persistBackup?: 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;
+    }): TaskItem | null;
+    bulkArchive(ids: string[], isCancellation?: boolean, workspaceId?: string): number;
+    applyWorkspaceSyncSnapshot(input: {
+        tasks?: Array<Partial<TaskItem>>;
+        archived?: Array<Partial<TaskItem>>;
+    }, workspaceId?: string): {
+        total: number;
+        created: number;
+        updated: number;
+        archived: number;
+        unarchived: number;
+        skipped: number;
+    };
+    updateConfig(newConfig: any): void;
+    getUiState(workspaceId: string, userId: string, stateKey?: string): Record<string, unknown> | null;
+    updateUiState(workspaceId: string, userId: string, input: {
+        stateKey?: string;
+        patch: Record<string, unknown>;
+    }): 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;
+    listSyncEvents(workspaceId: string, limit?: number): Array<{
+        id: number;
+        eventType: string;
+        status: string;
+        statusCode: number | null;
+        errorMessage: string | null;
+        changeCount: number | null;
+        requestMs: number | null;
+        occurredAt: string;
+    }>;
+    /**
+     * Returns the persisted updatedAt watermark and content hash for a document path.
+     * Returns null if no record exists yet.
+     */
+    getDocumentWatermark(workspaceId: string, docPath: string): {
+        updatedAt: string;
+        contentHash: string;
+    } | null;
+    hasDocumentPathInOtherWorkspaces(workspaceId: string, docPath: string): boolean;
+    hasTaskAssetPathInOtherWorkspaces(workspaceId: string, pathValue: string): boolean;
+    /**
+     * Upserts the watermark for a document path. If the content hash matches the existing
+     * 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;
+    deleteDocumentWatermark(workspaceId: string, docPath: string): void;
+    getCategories(): CategoryConfig[];
+    updateCategories(categories: Array<string | CategoryConfig>): void;
+    searchTasks(query: string, scope?: 'all' | 'active' | 'archive', workspaceId?: string): TaskItem[];
+    getTypes(): Array<{
+        value: string;
+        label: string;
+    }>;
+    updateTypes(types: Array<{
+        value: string;
+        label: string;
+    }>): void;
+    getTaxonomies(): any[];
+    getTaxonomiesSyncSnapshot(): {
+        taxonomies: any[];
+        updatedAt: string;
+    };
+    updateTaxonomies(taxonomies: any[]): void;
+    getPriorities(): Array<{
+        value: number;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>;
+    updatePriorities(priorities: Array<{
+        value: number;
+        label: string;
+        color?: string;
+        icon?: 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;
+    private listDirectChildren;
+    getInitiativeTemplates(): InitiativeTemplate[];
+    createInitiativeFromTemplate(input: {
+        templateId: string;
+        title: string;
+        description?: string;
+        category?: string;
+        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;
+        [key: string]: any;
+    }>, workspaceId?: string): BulkUpdateFieldsPreview;
+    bulkUpdateFields(updates: Array<{
+        id: string;
+        [key: string]: any;
+    }>, workspaceId?: string): {
+        updated: number;
+        total: number;
+        deduped: number;
+        skippedNoop: number;
+        invalid: number;
+        notFound: number;
+        changes: Array<{
+            id: string;
+            fields: string[];
+        }>;
+    };
+    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[];
+    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.
+     */
+    private persistBackup;
+}
+export {};