@taskforcehq/taskforce 0.3.304 → 0.3.305

package/dist/core/TaskTaxonomyValidation.test.js

@@ -348,6 +348,59 @@ describe('TaskforceCore taxonomy validation', () => {
         core.close();
         fs.rmSync(projectRoot, { recursive: true, force: true });
     });
+    it('migrates legacy config-backed taxonomy data once and no longer depends on config for runtime state', () => {
+        const projectRoot = makeTempProjectRoot();
+        fs.mkdirSync(path.join(projectRoot, '.taskforce'), { recursive: true });
+        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            categories: [{ value: 'legacy', label: 'Legacy' }],
+            types: [{ value: 'legacy-type', label: 'Legacy Type' }],
+            priorities: [{ value: 9, label: 'Legacy Priority', color: 'red-500', icon: 'AlertTriangle' }],
+            taxonomies: [{ id: 'legacy-taxonomy', label: 'Legacy Taxonomy', widgetType: 'select', isSystem: false, multiSelect: false, options: [] }]
+        }, null, 2));
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const migratedState = core.getTaxonomyState('default');
+        expect((migratedState.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default', 'legacy']);
+        expect((migratedState.types || []).map((type) => type.value)).toEqual(['legacy-type']);
+        expect((migratedState.priorities || []).map((priority) => priority.value)).toEqual([9]);
+        expect((migratedState.taxonomies || []).map((taxonomy) => taxonomy.id)).toEqual(['legacy-taxonomy']);
+        core.close();
+        fs.writeFileSync(configPath, JSON.stringify({ checklistDropdownEnabled: true }, null, 2));
+        const reopened = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const persistedState = reopened.getTaxonomyState('default');
+        expect((persistedState.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default', 'legacy']);
+        expect((persistedState.types || []).map((type) => type.value)).toEqual(['legacy-type']);
+        expect((persistedState.priorities || []).map((priority) => priority.value)).toEqual([9]);
+        expect((persistedState.taxonomies || []).map((taxonomy) => taxonomy.id)).toEqual(['legacy-taxonomy']);
+        reopened.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('does not seed new workspaces from legacy config-backed taxonomy definitions', () => {
+        const projectRoot = makeTempProjectRoot();
+        fs.mkdirSync(path.join(projectRoot, '.taskforce'), { recursive: true });
+        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            categories: [{ value: 'legacy', label: 'Legacy' }],
+            types: [{ value: 'legacy-type', label: 'Legacy Type' }],
+            priorities: [{ value: 9, label: 'Legacy Priority' }],
+            taxonomies: [{ id: 'legacy-taxonomy', label: 'Legacy Taxonomy' }]
+        }, null, 2));
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-new', name: 'New Workspace' });
+        const state = core.getTaxonomyState('workspace-new');
+        expect((state.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default']);
+        expect((state.types || []).map((type) => type.value)).toEqual([
+            'task',
+            'deliverable',
+            'issue',
+            'idea',
+            'review'
+        ]);
+        expect((state.priorities || []).map((priority) => priority.value)).toEqual([1, 2, 3]);
+        expect(state.taxonomies || []).toEqual([]);
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
     it('preserves existing first-class taxonomy sections when taxonomy state updates are partial', () => {
         const projectRoot = makeTempProjectRoot();
         const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });

package/dist/core/Taskforce.d.ts

@@ -911,6 +911,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     getAccountAccessStatus(accountId: string): import("./types.js").AccountAccessStatus;
     getEffectivePlanVersion(accountId: string): import("./types.js").PlanVersionSnapshot;
     getAccountEntitlement(accountId: string): import("./types.js").AccountEntitlementSnapshot;
+    countAiProfileUsage(workspaceId: string): import("./types.js").SeatUsageSnapshot;
     countWorkspaceSeatUsage(workspaceId: string, options?: {
         includeInvited?: boolean;
     }): import("./types.js").SeatUsageSnapshot;
@@ -968,6 +969,8 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     private resolveDefaultTypeValue;
     private getLegacyTaxonomiesConfig;
     private getLegacyPrioritiesConfig;
+    private readLegacyWorkspaceTaxonomyStateFromConfig;
+    private migrateLegacyWorkspaceTaxonomyStateIfNeeded;
     private buildEmergencyWorkspaceTaxonomyState;
     private getConfiguredDefaultStarterTaxonomyPackId;
     private getResolvedStarterWorkspaceTaxonomyState;

package/dist/core/Taskforce.js

@@ -79,7 +79,7 @@ const DEFAULT_PLAN_FEATURE_CATALOG = [
         featureKey: DOCUMENT_CLOUD_STORAGE_FEATURE_KEY,
         label: 'Document Cloud Storage',
         description: 'Allow cloud document storage with an optional storage allowance in MB.',
-        allowedAccessModes: ['enabled', 'disabled'],
+        allowedAccessModes: ['enabled', 'limited', 'disabled'],
         configTemplate: {
             [DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY]: 1024
         }
@@ -1261,6 +1261,9 @@ export class TaskforceCore {
     getAccountEntitlement(accountId) {
         return this.planEntitlementService.getAccountEntitlement(accountId);
     }
+    countAiProfileUsage(workspaceId) {
+        return this.planEntitlementService.countAiProfileUsage(workspaceId);
+    }
     countWorkspaceSeatUsage(workspaceId, options = {}) {
         return this.planEntitlementService.countWorkspaceSeatUsage(workspaceId, options);
     }
@@ -2414,6 +2417,42 @@ export class TaskforceCore {
         }
         return [];
     }
+    readLegacyWorkspaceTaxonomyStateFromConfig() {
+        const legacyCategories = this.getLegacyCategoriesConfig();
+        const legacyTypes = this.getLegacyTypesConfig();
+        const legacyPriorities = this.getLegacyPrioritiesConfig();
+        const legacyTaxonomies = this.getLegacyTaxonomiesConfig();
+        if (legacyCategories.length === 0
+            && legacyTypes.length === 0
+            && legacyPriorities.length === 0
+            && legacyTaxonomies.length === 0) {
+            return null;
+        }
+        return normalizeWorkspaceTaxonomyStatePayload({
+            categories: legacyCategories,
+            types: legacyTypes,
+            priorities: legacyPriorities,
+            taxonomies: legacyTaxonomies
+        });
+    }
+    migrateLegacyWorkspaceTaxonomyStateIfNeeded(workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        if (normalizedWorkspaceId !== 'default') {
+            return null;
+        }
+        const stored = this.readStoredWorkspaceTaxonomyState(normalizedWorkspaceId);
+        if (Object.keys(stored.state).length > 0) {
+            return stored;
+        }
+        const legacyState = this.readLegacyWorkspaceTaxonomyStateFromConfig();
+        if (!legacyState)
+            return null;
+        const persisted = this.writeWorkspaceTaxonomyState(legacyState, normalizedWorkspaceId);
+        return {
+            state: persisted.state,
+            updatedAt: persisted.updatedAt
+        };
+    }
     buildEmergencyWorkspaceTaxonomyState() {
         const emergencyPack = getEmergencyStarterTaxonomyLibraryPack();
         return {
@@ -2454,17 +2493,13 @@ export class TaskforceCore {
     }
     getEffectiveWorkspaceTaxonomyState(workspaceId) {
         const { state } = this.readStoredWorkspaceTaxonomyState(workspaceId);
-        const legacyCategories = this.getLegacyCategoriesConfig();
-        const legacyTypes = this.getLegacyTypesConfig();
-        const legacyPriorities = this.getLegacyPrioritiesConfig();
-        const legacyTaxonomies = this.getLegacyTaxonomiesConfig();
         const starterState = this.getResolvedStarterWorkspaceTaxonomyState();
         const emergencyState = this.buildEmergencyWorkspaceTaxonomyState();
         return normalizeWorkspaceTaxonomyStatePayload({
-            categories: state.categories || (legacyCategories.length > 0 ? legacyCategories : starterState.categories) || emergencyState.categories,
-            types: state.types || (legacyTypes.length > 0 ? legacyTypes : starterState.types) || emergencyState.types,
-            priorities: state.priorities || (legacyPriorities.length > 0 ? legacyPriorities : starterState.priorities) || emergencyState.priorities,
-            taxonomies: state.taxonomies || (legacyTaxonomies.length > 0 ? legacyTaxonomies : starterState.taxonomies) || emergencyState.taxonomies
+            categories: state.categories || starterState.categories || emergencyState.categories,
+            types: state.types || starterState.types || emergencyState.types,
+            priorities: state.priorities || starterState.priorities || emergencyState.priorities,
+            taxonomies: state.taxonomies || starterState.taxonomies || emergencyState.taxonomies
         });
     }
     ensureWorkspaceTaxonomyStateSeeded(workspaceId) {
@@ -2473,6 +2508,10 @@ export class TaskforceCore {
         if (Object.keys(stored.state).length > 0) {
             return stored;
         }
+        const migratedLegacy = this.migrateLegacyWorkspaceTaxonomyStateIfNeeded(normalizedWorkspaceId);
+        if (migratedLegacy) {
+            return migratedLegacy;
+        }
         const seededState = this.getEffectiveWorkspaceTaxonomyState(normalizedWorkspaceId);
         const persisted = this.writeWorkspaceTaxonomyState(seededState, normalizedWorkspaceId);
         return {
@@ -4912,7 +4951,8 @@ export class TaskforceCore {
             aiProfileRowToRecord: (row) => this.aiProfileRowToRecord(row),
             generateEntityId: (prefix) => this.generateEntityId(prefix),
             issueProfileToken: () => `tfp_${randomBytes(24).toString('hex')}`,
-            createRuleError: (message, statusCode = 400, code = 'TASK_RULE_VIOLATION') => new TaskforceRuleError(message, statusCode, code),
+            countAiProfileUsage: (workspaceId) => this.countAiProfileUsage(workspaceId),
+            createRuleError: (message, statusCode = 400, code = 'TASK_RULE_VIOLATION', details) => new TaskforceRuleError(message, statusCode, code, details),
         };
     }
     resolveWorkspaceActor(workspaceId, actorRef) {

package/dist/core/WorkspacePlanMode.test.js

@@ -20,30 +20,30 @@ function openCore(projectRoot) {
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         `).run('default', planVersionId, 'month', `free:${planVersionId}:month`, 'free', 1, 0, null, now, now);
     };
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter' });
-    addFreeMapping('starter-v1');
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'active' });
+    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free' });
+    addFreeMapping('free-v1');
+    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
     core.updatePlanVersion({
-        planId: 'starter',
+        planId: 'free',
         versionNumber: 1,
         seatLimit: 1
     });
     core.updatePlanVersionFeatures({
-        planVersionId: 'starter-v1',
+        planVersionId: 'free-v1',
         features: [
             { featureKey: 'workspace.switching', access: 'enabled' }
         ]
     });
-    core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab' });
-    addFreeMapping('collab-v1');
-    core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab', status: 'active' });
+    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5' });
+    addFreeMapping('team-5-v1');
+    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
     core.updatePlanVersion({
-        planId: 'collab',
+        planId: 'team-5',
         versionNumber: 1,
         seatLimit: 5
     });
     core.updatePlanVersionFeatures({
-        planVersionId: 'collab-v1',
+        planVersionId: 'team-5-v1',
         features: [
             { featureKey: 'collaboration.invites', access: 'enabled' },
             { featureKey: 'collaboration.team_management', access: 'enabled' }
@@ -233,7 +233,7 @@ describe('TaskforceCore account-level plan mode and invite revoke', () => {
                 billing: {
                     onboardingPolicy: {
                         mode: 'auto_grant_free',
-                        planVersionId: 'starter-v1'
+                        planVersionId: 'free-v1'
                     }
                 }
             });
@@ -266,7 +266,7 @@ describe('TaskforceCore account-level plan mode and invite revoke', () => {
             expect(accepted.workspaceId).toBe('workspace-invite');
             expect(core.hasAccountEntitlement('invited-user')).toBe(true);
             expect(core.getAccountEntitlement('invited-user')).toEqual(expect.objectContaining({
-                planVersionId: 'starter-v1',
+                planVersionId: 'free-v1',
                 state: 'active'
             }));
             expect(core.getAccountAccessStatus('invited-user')).toEqual(expect.objectContaining({

package/dist/core/shared.d.ts

@@ -17,8 +17,10 @@
 import type { McpAccessTokenScope, PlanFeatureCatalogItem } from './types.js';
 export declare const DOCUMENT_CLOUD_STORAGE_FEATURE_KEY = "context.uploads";
 export declare const WORKSPACES_FEATURE_KEY = "workspace.switching";
+export declare const AI_PROFILES_FEATURE_KEY = "collaboration.ai_profiles";
 export declare const DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY = "storageLimitMb";
 export declare const WORKSPACES_LIMIT_CONFIG_KEY = "maxWorkspaces";
+export declare const AI_PROFILES_LIMIT_CONFIG_KEY = "maxAiProfiles";
 export declare const MCP_ACCESS_TOKEN_MAX_ACTIVE_PER_USER_WORKSPACE = 10;
 export declare const MCP_ACCESS_TOKEN_DEFAULT_PAGE_SIZE = 20;
 export declare const MCP_ACCESS_TOKEN_MAX_PAGE_SIZE = 100;

package/dist/core/shared.js

@@ -18,8 +18,10 @@ import { createHash, pbkdf2Sync, randomBytes, timingSafeEqual } from 'crypto';
 // === SECTION: Constants ===
 export const DOCUMENT_CLOUD_STORAGE_FEATURE_KEY = 'context.uploads';
 export const WORKSPACES_FEATURE_KEY = 'workspace.switching';
+export const AI_PROFILES_FEATURE_KEY = 'collaboration.ai_profiles';
 export const DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY = 'storageLimitMb';
 export const WORKSPACES_LIMIT_CONFIG_KEY = 'maxWorkspaces';
+export const AI_PROFILES_LIMIT_CONFIG_KEY = 'maxAiProfiles';
 export const MCP_ACCESS_TOKEN_MAX_ACTIVE_PER_USER_WORKSPACE = 10;
 export const MCP_ACCESS_TOKEN_DEFAULT_PAGE_SIZE = 20;
 export const MCP_ACCESS_TOKEN_MAX_PAGE_SIZE = 100;
@@ -50,6 +52,15 @@ export const DEFAULT_PLAN_FEATURE_CATALOG = [
         configTemplate: {
             [WORKSPACES_LIMIT_CONFIG_KEY]: 1
         }
+    },
+    {
+        featureKey: AI_PROFILES_FEATURE_KEY,
+        label: 'AI Profiles',
+        description: 'Allow registered AI collaborator profiles with an optional per-workspace limit.',
+        allowedAccessModes: ['enabled', 'limited', 'disabled'],
+        configTemplate: {
+            [AI_PROFILES_LIMIT_CONFIG_KEY]: 1
+        }
     }
 ];
 export const PLAN_FEATURE_DEPENDENCIES = Object.freeze(DEFAULT_PLAN_FEATURE_CATALOG.reduce((acc, feature) => {

package/dist/hooks/sync/auth.js

@@ -49,7 +49,9 @@ export function createSyncAuthCoordinator({ currentWorkspaceId, workspaceSyncPha
         if (ensured.transient || isTransientWorkspaceSyncStatus(ensured.statusCode)) {
             scheduleWorkspaceSyncRetry(ensured.retryAfterMs);
         }
-        else if (workspaceSyncPhase === 'active') {
+        else if (workspaceSyncPhase === 'active'
+            || workspaceSyncPhase === 'attach-cloud'
+            || workspaceSyncPhase === 'provision-local') {
             persistWorkspaceSyncPatchSafely({ phase: 'error', lastErrorMessage: message });
         }
         return false;

package/dist/hooks/sync/transfers.d.ts

@@ -74,6 +74,7 @@ interface CreateWorkspaceTransferCoordinatorArgs {
     workspacePendingSignatureRef: MutableRefObject<string>;
     workspaceLastPushedTaskIdsRef: MutableRefObject<Set<string>>;
     workspaceDeletedTaskIdsRef: MutableRefObject<Set<string>>;
+    workspaceDeletedTaskWatermarksRef: MutableRefObject<Map<string, string>>;
     workspacePullCursorRef: MutableRefObject<string | null>;
     workspaceLastPushedWatermarksRef: MutableRefObject<Map<string, string>>;
     workspaceLastPushedInitiativeIdsRef: MutableRefObject<Set<string>>;
@@ -109,7 +110,7 @@ interface CreateWorkspaceTransferCoordinatorArgs {
     setTasks: Dispatch<SetStateAction<any[]>>;
     setArchivedTasks: Dispatch<SetStateAction<any[]>>;
 }
-export declare function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtimeMode, workspaceCloudSyncEnabled, currentWorkspaceId, workspaceSyncPhase, taxonomyStateFingerprint, isAuthenticated, checkAuthSession, resolveCloudAuthUrl, ensureCloudWorkspaceReadyForSync, ensureWorkspaceSyncReady, handleSyncAuthFailure, clearWorkspaceRetry, clearWorkspaceIssue, isWorkspaceRetryPending, scheduleWorkspaceSyncRetry, persistWorkspaceSyncPatchSafely, persistWorkspaceSyncPatchBestEffort, reportSyncEvent, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, reportWorkspaceWindowContention, refreshWorkspaceSyncMarkdownDocumentsSnapshot, refreshWorkspaceSyncAiProfilesSnapshot, refreshWorkspaceSyncAssetsSnapshot, refreshWorkspaceSyncDocumentReviewSessionsSnapshot, refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot, refreshLocalWorkspaceTaskCollections, buildWorkspaceSyncPayload, buildWorkspaceSyncSignature, seedWorkspaceSnapshotPushBaseline, shouldSuppressAttachBootstrapPush, recordSuppressedEventIds, workspaceRepairModeRef, workspaceForceFullAiProfilePushRef, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspacePullCursorRef, workspaceLastPushedWatermarksRef, workspaceLastPushedInitiativeIdsRef, workspaceLastPushedInitiativeWatermarksRef, workspaceLastPushedWorkstreamIdsRef, workspaceLastPushedWorkstreamWatermarksRef, workspaceLastPushedAiProfileIdsRef, workspaceLastPushedAiProfileWatermarksRef, workspaceLastPushedDocumentPathsRef, workspaceLastPushedDocumentWatermarksRef, workspaceLastPushedAssetPathsRef, workspaceLastPushedAssetWatermarksRef, workspaceLastPushedDocumentReviewSessionIdsRef, workspaceLastPushedDocumentReviewSessionWatermarksRef, workspaceLastPushedDocumentReviewCommentIdsRef, workspaceLastPushedDocumentReviewCommentWatermarksRef, workspaceLastPushedAnnotatedAttachmentSessionIdsRef, workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, workspaceLastPushedTaskEventWatermarksRef, workspaceCaptureAttachBootstrapBaselineRef, workspaceStartupFullReconcileRanRef, workspaceFullReconcileInFlightRef, bootstrapLastProgressAtRef, realtimeSuppressedEventQueueRef, setWorkspaceSyncBusy, setUserGlobalSyncStatus, setUserGlobalSyncError, setWorkspaceLastErrorMessage, setWorkspaceLastErrorAt, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceSyncPendingChanges, setTasks, setArchivedTasks }: CreateWorkspaceTransferCoordinatorArgs): {
+export declare function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtimeMode, workspaceCloudSyncEnabled, currentWorkspaceId, workspaceSyncPhase, taxonomyStateFingerprint, isAuthenticated, checkAuthSession, resolveCloudAuthUrl, ensureCloudWorkspaceReadyForSync, ensureWorkspaceSyncReady, handleSyncAuthFailure, clearWorkspaceRetry, clearWorkspaceIssue, isWorkspaceRetryPending, scheduleWorkspaceSyncRetry, persistWorkspaceSyncPatchSafely, persistWorkspaceSyncPatchBestEffort, reportSyncEvent, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, reportWorkspaceWindowContention, refreshWorkspaceSyncMarkdownDocumentsSnapshot, refreshWorkspaceSyncAiProfilesSnapshot, refreshWorkspaceSyncAssetsSnapshot, refreshWorkspaceSyncDocumentReviewSessionsSnapshot, refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot, refreshLocalWorkspaceTaskCollections, buildWorkspaceSyncPayload, buildWorkspaceSyncSignature, seedWorkspaceSnapshotPushBaseline, shouldSuppressAttachBootstrapPush, recordSuppressedEventIds, workspaceRepairModeRef, workspaceForceFullAiProfilePushRef, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, workspaceLastPushedWatermarksRef, workspaceLastPushedInitiativeIdsRef, workspaceLastPushedInitiativeWatermarksRef, workspaceLastPushedWorkstreamIdsRef, workspaceLastPushedWorkstreamWatermarksRef, workspaceLastPushedAiProfileIdsRef, workspaceLastPushedAiProfileWatermarksRef, workspaceLastPushedDocumentPathsRef, workspaceLastPushedDocumentWatermarksRef, workspaceLastPushedAssetPathsRef, workspaceLastPushedAssetWatermarksRef, workspaceLastPushedDocumentReviewSessionIdsRef, workspaceLastPushedDocumentReviewSessionWatermarksRef, workspaceLastPushedDocumentReviewCommentIdsRef, workspaceLastPushedDocumentReviewCommentWatermarksRef, workspaceLastPushedAnnotatedAttachmentSessionIdsRef, workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, workspaceLastPushedTaskEventWatermarksRef, workspaceCaptureAttachBootstrapBaselineRef, workspaceStartupFullReconcileRanRef, workspaceFullReconcileInFlightRef, bootstrapLastProgressAtRef, realtimeSuppressedEventQueueRef, setWorkspaceSyncBusy, setUserGlobalSyncStatus, setUserGlobalSyncError, setWorkspaceLastErrorMessage, setWorkspaceLastErrorAt, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceSyncPendingChanges, setTasks, setArchivedTasks }: CreateWorkspaceTransferCoordinatorArgs): {
     pushWorkspaceChangesToCloud: (signature: string, options?: {
         forceAllAiProfiles?: boolean;
         repairMode?: boolean;

package/dist/hooks/sync/transfers.js

@@ -1,7 +1,7 @@
 import { applyLocalWorkspaceChanges } from '../../sync/cloudSyncApi';
 import { isTransientWorkspaceSyncStatus, runWorkspacePullSyncService, runWorkspacePushSyncService } from '../../sync/syncService';
 import { logSyncDebug, savePersistedSyncWatermarks, isValidWorkspaceKey } from './orchestratorShared';
-export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtimeMode, workspaceCloudSyncEnabled, currentWorkspaceId, workspaceSyncPhase, taxonomyStateFingerprint, isAuthenticated, checkAuthSession, resolveCloudAuthUrl, ensureCloudWorkspaceReadyForSync, ensureWorkspaceSyncReady, handleSyncAuthFailure, clearWorkspaceRetry, clearWorkspaceIssue, isWorkspaceRetryPending, scheduleWorkspaceSyncRetry, persistWorkspaceSyncPatchSafely, persistWorkspaceSyncPatchBestEffort, reportSyncEvent, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, reportWorkspaceWindowContention, refreshWorkspaceSyncMarkdownDocumentsSnapshot, refreshWorkspaceSyncAiProfilesSnapshot, refreshWorkspaceSyncAssetsSnapshot, refreshWorkspaceSyncDocumentReviewSessionsSnapshot, refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot, refreshLocalWorkspaceTaskCollections, buildWorkspaceSyncPayload, buildWorkspaceSyncSignature, seedWorkspaceSnapshotPushBaseline, shouldSuppressAttachBootstrapPush, recordSuppressedEventIds, workspaceRepairModeRef, workspaceForceFullAiProfilePushRef, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspacePullCursorRef, workspaceLastPushedWatermarksRef, workspaceLastPushedInitiativeIdsRef, workspaceLastPushedInitiativeWatermarksRef, workspaceLastPushedWorkstreamIdsRef, workspaceLastPushedWorkstreamWatermarksRef, workspaceLastPushedAiProfileIdsRef, workspaceLastPushedAiProfileWatermarksRef, workspaceLastPushedDocumentPathsRef, workspaceLastPushedDocumentWatermarksRef, workspaceLastPushedAssetPathsRef, workspaceLastPushedAssetWatermarksRef, workspaceLastPushedDocumentReviewSessionIdsRef, workspaceLastPushedDocumentReviewSessionWatermarksRef, workspaceLastPushedDocumentReviewCommentIdsRef, workspaceLastPushedDocumentReviewCommentWatermarksRef, workspaceLastPushedAnnotatedAttachmentSessionIdsRef, workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, workspaceLastPushedTaskEventWatermarksRef, workspaceCaptureAttachBootstrapBaselineRef, workspaceStartupFullReconcileRanRef, workspaceFullReconcileInFlightRef, bootstrapLastProgressAtRef, realtimeSuppressedEventQueueRef, setWorkspaceSyncBusy, setUserGlobalSyncStatus, setUserGlobalSyncError, setWorkspaceLastErrorMessage, setWorkspaceLastErrorAt, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceSyncPendingChanges, setTasks, setArchivedTasks }) {
+export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtimeMode, workspaceCloudSyncEnabled, currentWorkspaceId, workspaceSyncPhase, taxonomyStateFingerprint, isAuthenticated, checkAuthSession, resolveCloudAuthUrl, ensureCloudWorkspaceReadyForSync, ensureWorkspaceSyncReady, handleSyncAuthFailure, clearWorkspaceRetry, clearWorkspaceIssue, isWorkspaceRetryPending, scheduleWorkspaceSyncRetry, persistWorkspaceSyncPatchSafely, persistWorkspaceSyncPatchBestEffort, reportSyncEvent, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, reportWorkspaceWindowContention, refreshWorkspaceSyncMarkdownDocumentsSnapshot, refreshWorkspaceSyncAiProfilesSnapshot, refreshWorkspaceSyncAssetsSnapshot, refreshWorkspaceSyncDocumentReviewSessionsSnapshot, refreshWorkspaceSyncAnnotatedAttachmentSessionsSnapshot, refreshLocalWorkspaceTaskCollections, buildWorkspaceSyncPayload, buildWorkspaceSyncSignature, seedWorkspaceSnapshotPushBaseline, shouldSuppressAttachBootstrapPush, recordSuppressedEventIds, workspaceRepairModeRef, workspaceForceFullAiProfilePushRef, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, workspaceLastPushedWatermarksRef, workspaceLastPushedInitiativeIdsRef, workspaceLastPushedInitiativeWatermarksRef, workspaceLastPushedWorkstreamIdsRef, workspaceLastPushedWorkstreamWatermarksRef, workspaceLastPushedAiProfileIdsRef, workspaceLastPushedAiProfileWatermarksRef, workspaceLastPushedDocumentPathsRef, workspaceLastPushedDocumentWatermarksRef, workspaceLastPushedAssetPathsRef, workspaceLastPushedAssetWatermarksRef, workspaceLastPushedDocumentReviewSessionIdsRef, workspaceLastPushedDocumentReviewSessionWatermarksRef, workspaceLastPushedDocumentReviewCommentIdsRef, workspaceLastPushedDocumentReviewCommentWatermarksRef, workspaceLastPushedAnnotatedAttachmentSessionIdsRef, workspaceLastPushedAnnotatedAttachmentSessionWatermarksRef, workspaceLastPushedTaskEventWatermarksRef, workspaceCaptureAttachBootstrapBaselineRef, workspaceStartupFullReconcileRanRef, workspaceFullReconcileInFlightRef, bootstrapLastProgressAtRef, realtimeSuppressedEventQueueRef, setWorkspaceSyncBusy, setUserGlobalSyncStatus, setUserGlobalSyncError, setWorkspaceLastErrorMessage, setWorkspaceLastErrorAt, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceSyncPendingChanges, setTasks, setArchivedTasks }) {
     const pushWorkspaceChangesToCloud = async (signature, options) => {
         if (!cloudAuthConfigured || runtimeMode !== 'local' || !workspaceCloudSyncEnabled)
             return false;
@@ -115,6 +115,7 @@ export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtim
             if (pushResult.deleteTaskIds.size > 0) {
                 for (const taskId of pushResult.deleteTaskIds) {
                     workspaceDeletedTaskIdsRef.current.delete(taskId);
+                    workspaceDeletedTaskWatermarksRef.current.delete(taskId);
                     workspaceLastPushedWatermarksRef.current.delete(taskId);
                 }
             }
@@ -214,12 +215,15 @@ export function createWorkspaceTransferCoordinator({ cloudAuthConfigured, runtim
             setWorkspaceSyncBusy(workspacePullInFlightRef.current);
             releaseWorkspaceSyncLease(currentWorkspaceId);
             const pendingSignature = workspacePendingSignatureRef.current;
+            const latestSignature = buildWorkspaceSyncSignature();
             if (pendingSignature
-                && pendingSignature !== workspaceLastPushedSignatureRef.current
-                && !workspacePullInFlightRef.current) {
+                && latestSignature
+                && latestSignature !== workspaceLastPushedSignatureRef.current
+                && !workspacePullInFlightRef.current
+                && !isWorkspaceRetryPending()) {
                 workspacePendingSignatureRef.current = '';
                 window.setTimeout(() => {
-                    void pushWorkspaceChangesToCloud(pendingSignature);
+                    void pushWorkspaceChangesToCloud(latestSignature);
                 }, 120);
             }
         }

package/dist/hooks/useSyncOrchestrator.d.ts

@@ -1,5 +1,5 @@
-import type { InitiativeItem, TaskItem, TaskforceTheme, WorkstreamItem } from '../types';
-import { type WorkspaceSyncPhase } from '../sync/workspaceSyncState';
+import type { DeletedTaskRecord, InitiativeItem, TaskItem, TaskforceTheme, WorkstreamItem } from '../types';
+import { type WorkspaceSyncPhase, type WorkspaceSyncSetupIntent } from '../sync/workspaceSyncState';
 import type { WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
 import type { SupportedLocale } from '../localization';
 import { normalizeWorkspaceSyncAiProfileSnapshotEntry } from './sync/orchestratorShared';
@@ -16,6 +16,7 @@ export interface UseSyncOrchestratorInput {
     realtimeSyncEnabled: boolean;
     tasks: TaskItem[];
     archivedTasks: TaskItem[];
+    deletedTasks?: DeletedTaskRecord[];
     initiatives: InitiativeItem[];
     workstreams: WorkstreamItem[];
     taxonomies: unknown[];
@@ -53,6 +54,7 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
     workspaceLastSuccessfulSyncAt: string | null;
     workspaceCloudSyncEnabled: boolean;
     workspaceSyncPhase: WorkspaceSyncPhase;
+    workspaceSyncSetupIntent: WorkspaceSyncSetupIntent;
     workspaceSyncStatus: WorkspaceSyncStatus;
     workspaceSyncSummary: string;
     workspaceSyncRecommendedAction: string;
@@ -67,14 +69,15 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
     workspacePendingSignatureRef: import("react").RefObject<string>;
     workspaceLastPushedTaskIdsRef: import("react").RefObject<Set<string>>;
     workspaceDeletedTaskIdsRef: import("react").RefObject<Set<string>>;
+    workspaceDeletedTaskWatermarksRef: import("react").RefObject<Map<string, string>>;
     workspacePullCursorRef: import("react").RefObject<string | null>;
     clearWorkspaceRetry: () => void;
     persistWorkspaceSyncPatch: (patch: Partial<import("../sync/workspaceSyncState").WorkspaceSyncStateV2>) => Promise<import("../sync/workspaceSyncState").WorkspaceSyncStateV2>;
     loadWorkspaceSyncState: () => Promise<void>;
-    applyWorkspaceSyncStateSnapshot: (nextState: Partial<import("../sync/workspaceSyncState").WorkspaceSyncStateV2> & {
+    applyWorkspaceSyncStateSnapshot: (nextState: Parameters<(nextState: Partial<import("../sync/workspaceSyncState").WorkspaceSyncStateV2> & {
         enabled: boolean;
         phase?: WorkspaceSyncPhase | null;
-    }) => void;
+    }) => void>[0]) => void;
     syncUserGlobalSettings: (options?: {
         preferCloudOnFirstSync?: boolean;
     }) => Promise<void>;

package/dist/hooks/useSyncOrchestrator.js

@@ -86,7 +86,7 @@ const EMPTY_WORKSPACE_SYNC_REFERENCE_SNAPSHOT_STATUS = {
 };
 export { normalizeWorkspaceSyncAiProfileSnapshotEntry };
 export function useSyncOrchestrator(input) {
-    const { currentWorkspaceId, cloudAuthConfigured, runtimeMode, authSessionResolved, isAuthenticated, authUserId, projectName, resolveCloudAuthUrl, resolveWebSocketUrl, realtimeSyncEnabled, tasks, archivedTasks, initiatives, workstreams, taxonomies, taxonomyState, setupState, globalTheme, locale, globalWeekStartsOn, themeUseGlobalDefault, setTasks, setArchivedTasks, setAuthBlocked, setIsAuthenticated, checkAuthSession, setGlobalTheme, setCurrentTheme, setSetupState, setLocale, setGlobalWeekStartsOn, fetchPlanningEntities } = input;
+    const { currentWorkspaceId, cloudAuthConfigured, runtimeMode, authSessionResolved, isAuthenticated, authUserId, projectName, resolveCloudAuthUrl, resolveWebSocketUrl, realtimeSyncEnabled, tasks, archivedTasks, deletedTasks = [], initiatives, workstreams, taxonomies, taxonomyState, setupState, globalTheme, locale, globalWeekStartsOn, themeUseGlobalDefault, setTasks, setArchivedTasks, setAuthBlocked, setIsAuthenticated, checkAuthSession, setGlobalTheme, setCurrentTheme, setSetupState, setLocale, setGlobalWeekStartsOn, fetchPlanningEntities } = input;
     const taxonomyStateFingerprint = useMemo(() => buildTaxonomyStateFingerprint(taxonomyState), [taxonomyState]);
     // === SECTION: State initialization ===
     const [userGlobalSyncStatus, setUserGlobalSyncStatus] = useState('disconnected');
@@ -97,6 +97,7 @@ export function useSyncOrchestrator(input) {
     const [workspaceLastErrorMessage, setWorkspaceLastErrorMessage] = useState(null);
     const [workspaceCloudSyncEnabled, setWorkspaceCloudSyncEnabled] = useState(false);
     const [workspaceSyncPhase, setWorkspaceSyncPhase] = useState('idle');
+    const [workspaceSyncSetupIntent, setWorkspaceSyncSetupIntent] = useState(null);
     const [workspaceSyncBusy, setWorkspaceSyncBusy] = useState(false);
     const [workspaceSyncPendingChanges, setWorkspaceSyncPendingChanges] = useState(0);
     const [workspaceSyncMarkdownDocuments, setWorkspaceSyncMarkdownDocuments] = useState([]);
@@ -253,14 +254,25 @@ export function useSyncOrchestrator(input) {
             }));
     }, []);
     const workspaceSyncReferenceSnapshotsReady = Object.values(workspaceSyncReferenceSnapshotStatus).every(Boolean);
-    const { workspaceRetryAt, isWorkspaceRetryPending, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspacePullCursorRef, clearWorkspaceRetry, scheduleWorkspaceRetry, persistWorkspaceSyncPatch, applyWorkspaceSyncPatchLocally, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot, saveWorkspaceCloudSyncSettings: saveWorkspaceCloudSyncSettingsBase, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, forceClearWorkspaceSyncLease } = useWorkspaceSyncController({
+    const { workspaceRetryAt, isWorkspaceRetryPending, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspaceDeletedTaskWatermarksRef, workspacePullCursorRef, clearWorkspaceRetry, scheduleWorkspaceRetry, persistWorkspaceSyncPatch, applyWorkspaceSyncPatchLocally, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot: applyWorkspaceSyncStateSnapshotBase, saveWorkspaceCloudSyncSettings: saveWorkspaceCloudSyncSettingsBase, acquireWorkspaceSyncLease, releaseWorkspaceSyncLease, forceClearWorkspaceSyncLease } = useWorkspaceSyncController({
         currentWorkspaceId,
         setWorkspaceCloudSyncEnabled,
         setWorkspaceSyncPhase,
+        setWorkspaceSyncSetupIntent,
         setWorkspaceLastPullAt,
         setWorkspaceLastPushAt,
         setWorkspaceLastErrorMessage
     });
+    const applyWorkspaceSyncStateSnapshot = useCallback((nextState) => {
+        if (nextState.phase === 'attach-cloud' || nextState.phase === 'provision-local') {
+            lastBootstrapPhaseRef.current = nextState.phase;
+            if (bootstrapPhaseStartedAtRef.current === null) {
+                bootstrapPhaseStartedAtRef.current = Date.now();
+            }
+            bootstrapLastProgressAtRef.current = null;
+        }
+        applyWorkspaceSyncStateSnapshotBase(nextState);
+    }, [applyWorkspaceSyncStateSnapshotBase]);
     const workspaceLastPushedWatermarksRef = useRef(new Map());
     const workspaceLastPushedInitiativeIdsRef = useRef(new Set());
     const workspaceLastPushedInitiativeWatermarksRef = useRef(new Map());
@@ -286,6 +298,7 @@ export function useSyncOrchestrator(input) {
     const workspaceCaptureAttachBootstrapBaselineRef = useRef(false);
     const workspaceDocumentsRefreshIntervalMs = 30_000;
     const workspacePullIntervalMs = realtimeSyncEnabled ? 30_000 : 15_000;
+    const workspacePushWatchdogIntervalMs = Math.max(30_000, workspacePullIntervalMs);
     const workspaceLastSuccessfulSyncAt = useMemo(() => {
         const pullMs = workspaceLastPullAt ? Date.parse(workspaceLastPullAt) : NaN;
         const pushMs = workspaceLastPushAt ? Date.parse(workspaceLastPushAt) : NaN;
@@ -560,7 +573,8 @@ export function useSyncOrchestrator(input) {
             isAuthenticated,
             resolveCloudAuthUrl,
             workspaceId: currentWorkspaceId,
-            workspaceName: projectName || currentWorkspaceId
+            workspaceName: projectName || currentWorkspaceId,
+            allowProvisionOnMismatch: workspaceSyncPhase !== 'attach-cloud'
         });
     }, [
         cloudAuthConfigured,
@@ -568,7 +582,8 @@ export function useSyncOrchestrator(input) {
         isAuthenticated,
         resolveCloudAuthUrl,
         currentWorkspaceId,
-        projectName
+        projectName,
+        workspaceSyncPhase
     ]);
     useEffect(() => {
         workspaceTasksRef.current = tasks || [];
@@ -576,6 +591,14 @@ export function useSyncOrchestrator(input) {
     useEffect(() => {
         workspaceArchivedTasksRef.current = archivedTasks || [];
     }, [archivedTasks]);
+    useEffect(() => {
+        workspaceDeletedTaskWatermarksRef.current = new Map((deletedTasks || [])
+            .map((entry) => [
+            String(entry?.taskId || '').trim(),
+            String(entry?.deletedAt || '').trim()
+        ])
+            .filter(([taskId, deletedAt]) => taskId.length > 0 && Number.isFinite(Date.parse(deletedAt))));
+    }, [deletedTasks, workspaceDeletedTaskWatermarksRef]);
     useEffect(() => {
         workspaceInitiativesRef.current = initiatives || [];
     }, [initiatives]);
@@ -595,6 +618,7 @@ export function useSyncOrchestrator(input) {
             taskEvents: flattenTaskEvents(workspaceTasksRef.current, workspaceArchivedTasksRef.current),
             lastPushedTaskIds: workspaceLastPushedTaskIdsRef.current,
             pendingDeletedTaskIds: workspaceDeletedTaskIdsRef.current,
+            pendingDeletedTaskWatermarks: workspaceDeletedTaskWatermarksRef.current,
             initiatives: workspaceInitiativesRef.current,
             workstreams: workspaceWorkstreamsRef.current,
             taxonomies: taxonomies || [],
@@ -1175,6 +1199,7 @@ export function useSyncOrchestrator(input) {
         workspacePendingSignatureRef,
         workspaceLastPushedTaskIdsRef,
         workspaceDeletedTaskIdsRef,
+        workspaceDeletedTaskWatermarksRef,
         workspacePullCursorRef,
         workspaceLastPushedWatermarksRef,
         workspaceLastPushedInitiativeIdsRef,
@@ -1561,6 +1586,41 @@ export function useSyncOrchestrator(input) {
         workspacePushInFlightRef,
         workspacePullInFlightRef
     ]);
+    useEffect(() => {
+        if (!cloudAuthConfigured || runtimeMode !== 'local' || !workspaceCloudSyncEnabled || !authSessionResolved)
+            return;
+        if (workspaceSyncPhase !== 'active')
+            return;
+        if (!workspaceSyncReferenceSnapshotsReady)
+            return;
+        const intervalId = window.setInterval(() => {
+            if (workspacePushInFlightRef.current || workspacePullInFlightRef.current)
+                return;
+            if (isWorkspaceRetryPending())
+                return;
+            const signature = workspacePendingSignatureRef.current || buildWorkspaceSyncSignature();
+            if (!signature || signature === workspaceLastPushedSignatureRef.current)
+                return;
+            const pendingPayload = buildWorkspaceSyncPayload();
+            setWorkspaceSyncPendingChanges(pendingPayload.changes.length);
+            if (pendingPayload.changes.length === 0)
+                return;
+            void pushWorkspaceChangesToCloud(signature);
+        }, workspacePushWatchdogIntervalMs);
+        return () => window.clearInterval(intervalId);
+    }, [
+        cloudAuthConfigured,
+        runtimeMode,
+        workspaceCloudSyncEnabled,
+        authSessionResolved,
+        workspaceSyncPhase,
+        workspaceSyncReferenceSnapshotsReady,
+        buildWorkspaceSyncSignature,
+        buildWorkspaceSyncPayload,
+        pushWorkspaceChangesToCloud,
+        isWorkspaceRetryPending,
+        workspacePushWatchdogIntervalMs
+    ]);
     useEffect(() => {
         if (cloudAuthConfigured && runtimeMode === 'local' && workspaceCloudSyncEnabled)
             return;
@@ -1575,21 +1635,27 @@ export function useSyncOrchestrator(input) {
     useEffect(() => {
         if (!cloudAuthConfigured || runtimeMode !== 'local' || !workspaceCloudSyncEnabled || !authSessionResolved)
             return;
-        if (workspaceSyncPhase === 'provision-local')
+        if (workspaceSyncPhase === 'provision-local' || workspaceSyncPhase === 'error')
             return;
         if (isWorkspaceRetryPending())
             return;
-        void pullWorkspaceChangesFromCloud();
+        const shouldKickOffPull = workspaceSyncPhase === 'attach-cloud' || !workspaceLastPullAt;
+        if (shouldKickOffPull) {
+            void pullWorkspaceChangesFromCloud();
+        }
         const intervalId = window.setInterval(() => {
             void pullWorkspaceChangesFromCloud();
         }, workspacePullIntervalMs);
-        return () => window.clearInterval(intervalId);
+        return () => {
+            window.clearInterval(intervalId);
+        };
     }, [
         cloudAuthConfigured,
         runtimeMode,
         workspaceCloudSyncEnabled,
         authSessionResolved,
         workspaceSyncPhase,
+        workspaceLastPullAt,
         isWorkspaceRetryPending,
         pullWorkspaceChangesFromCloud,
         workspacePullIntervalMs
@@ -1718,6 +1784,7 @@ export function useSyncOrchestrator(input) {
         workspaceLastSuccessfulSyncAt,
         workspaceCloudSyncEnabled,
         workspaceSyncPhase,
+        workspaceSyncSetupIntent,
         workspaceSyncStatus,
         workspaceSyncSummary,
         workspaceSyncRecommendedAction,
@@ -1732,6 +1799,7 @@ export function useSyncOrchestrator(input) {
         workspacePendingSignatureRef,
         workspaceLastPushedTaskIdsRef,
         workspaceDeletedTaskIdsRef,
+        workspaceDeletedTaskWatermarksRef,
         workspacePullCursorRef,
         clearWorkspaceRetry,
         persistWorkspaceSyncPatch,