@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/documentReviews/DocumentReviewSessionStore.test.js

@@ -1,127 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { createDatabaseAdapter } from '../storage/createDatabaseAdapter.js';
-import { ensureDocumentReviewSessionsSchema, ensureTaskAssetsSchema, ensureWorkspaceAssetsSchema } from '../migrations/taskSchemaMigrations.js';
-import { DocumentReviewCommentStore } from './DocumentReviewCommentStore.js';
-import { DocumentReviewSessionStore } from './DocumentReviewSessionStore.js';
-function makeStore() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-document-reviews-'));
-    const dbPath = path.join(root, 'taskforce.db');
-    const db = createDatabaseAdapter({ sqliteDbPath: dbPath });
-    ensureTaskAssetsSchema(db);
-    ensureWorkspaceAssetsSchema(db);
-    ensureDocumentReviewSessionsSchema(db);
-    const store = new DocumentReviewSessionStore(db, 'default');
-    const commentStore = new DocumentReviewCommentStore(db, 'default');
-    return {
-        root,
-        db,
-        store,
-        commentStore,
-        cleanup() {
-            db.close();
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    };
-}
-describe('DocumentReviewSessionStore', () => {
-    const cleanups = [];
-    afterEach(() => {
-        while (cleanups.length > 0) {
-            cleanups.pop()?.();
-        }
-    });
-    it('creates and reads sessions without embedding comments', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        const created = ctx.store.create({
-            id: 'review-1',
-            workspaceId: 'workspace-1',
-            assetId: 'asset-doc-1',
-            documentId: 'doc-1',
-            documentVersion: 2,
-            title: 'Implementation review',
-        });
-        expect(created).toMatchObject({
-            id: 'review-1',
-            workspaceId: 'workspace-1',
-            assetId: 'asset-doc-1',
-            documentId: 'doc-1',
-            documentVersion: 2,
-            title: 'Implementation review',
-            status: 'open',
-        });
-        expect(created.comments).toEqual([]);
-    });
-    it('backfills embedded comment blobs into document_review_comments rows', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        ctx.db.prepare(`
-            INSERT INTO document_review_sessions (
-                id,
-                tenant_id,
-                workspace_id,
-                asset_id,
-                document_id,
-                document_version,
-                title,
-                status,
-                comments_json,
-                created_by_actor_id,
-                updated_by_actor_id,
-                created_at,
-                updated_at,
-                deleted_at
-            ) VALUES (?, 'default', 'workspace-1', 'asset-doc-1', 'doc-1', 2, 'Implementation review', 'open', ?, 'user-1', 'user-1', '2026-03-25T09:00:00.000Z', '2026-03-25T10:00:00.000Z', NULL)
-        `).run('review-legacy', JSON.stringify([
-            {
-                id: 'comment-1',
-                order: 1,
-                body: 'Needs a concrete rollout section.',
-                anchor: { kind: 'line-range', startLine: 12, endLine: 18 },
-                authorActorId: 'user-1',
-                createdAt: '2026-03-25T09:00:00.000Z',
-                updatedAt: '2026-03-25T09:00:00.000Z',
-                deletedAt: null,
-            },
-            {
-                id: 'comment-2',
-                order: 2,
-                body: 'Resolve the open question.',
-                anchor: { kind: 'quote', quote: 'Open Questions', prefix: '## ', suffix: '\\n' },
-                authorActorId: 'user-2',
-                createdAt: '2026-03-25T10:00:00.000Z',
-                updatedAt: '2026-03-25T10:00:00.000Z',
-                deletedAt: null,
-            },
-        ]));
-        ensureDocumentReviewSessionsSchema(ctx.db);
-        const comments = ctx.commentStore.listForSession('review-legacy', 'workspace-1');
-        expect(comments.map((comment) => comment.id)).toEqual(['comment-1', 'comment-2']);
-        expect(comments[0]).toMatchObject({
-            body: 'Needs a concrete rollout section.',
-            anchor: { kind: 'line-range', startLine: 12, endLine: 18 },
-        });
-    });
-    it('lists active sessions and keeps soft-deleted rows hidden by default', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        ctx.store.create({
-            id: 'review-a',
-            workspaceId: 'workspace-1',
-            assetId: 'asset-doc-1',
-        });
-        ctx.store.create({
-            id: 'review-b',
-            workspaceId: 'workspace-1',
-            assetId: 'asset-doc-1',
-        });
-        expect(ctx.store.softDelete('review-b', 'workspace-1')).toBe(true);
-        const active = ctx.store.listForAsset('asset-doc-1', 'workspace-1');
-        expect(active.map((session) => session.id)).toEqual(['review-a']);
-        const all = ctx.store.listForAsset('asset-doc-1', 'workspace-1', { includeDeleted: true });
-        expect(all.map((session) => session.id).sort()).toEqual(['review-a', 'review-b']);
-    });
-});

package/dist/hooks/authGuardPolicy.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/authGuardPolicy.test.js

@@ -1,76 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { deriveAuthGuardPolicy, shouldSkipDataVersionPolling, shouldSkipDataVersionTick } from './authGuardPolicy';
-describe('authGuardPolicy', () => {
-    it('does not defer or block protected APIs in local runtime', () => {
-        const policy = deriveAuthGuardPolicy({
-            shouldGateProtectedApiCalls: true,
-            runtimeMode: 'local',
-            authSessionResolved: false,
-            authRequiredForApi: true,
-            isAuthenticated: false
-        });
-        expect(policy.shouldDeferProtectedApiCalls).toBe(false);
-        expect(policy.shouldBlockProtectedApiCalls).toBe(false);
-        expect(policy.canCallProtectedApi).toBe(true);
-    });
-    it('defers protected APIs in cloud runtime before auth session resolves', () => {
-        const policy = deriveAuthGuardPolicy({
-            shouldGateProtectedApiCalls: true,
-            runtimeMode: 'cloud',
-            authSessionResolved: false,
-            authRequiredForApi: false,
-            isAuthenticated: false
-        });
-        expect(policy.shouldDeferProtectedApiCalls).toBe(true);
-        expect(policy.shouldBlockProtectedApiCalls).toBe(false);
-        expect(policy.canCallProtectedApi).toBe(false);
-    });
-    it('blocks protected APIs in cloud runtime when auth is required but user is not authenticated', () => {
-        const policy = deriveAuthGuardPolicy({
-            shouldGateProtectedApiCalls: true,
-            runtimeMode: 'cloud',
-            authSessionResolved: true,
-            authRequiredForApi: true,
-            isAuthenticated: false
-        });
-        expect(policy.shouldDeferProtectedApiCalls).toBe(false);
-        expect(policy.shouldBlockProtectedApiCalls).toBe(true);
-        expect(policy.canCallProtectedApi).toBe(false);
-    });
-    it('keeps data-version polling active only when preconditions are met', () => {
-        expect(shouldSkipDataVersionPolling({
-            isOpen: true,
-            authBlocked: false,
-            authRequiredForApi: false,
-            isAuthenticated: false,
-            canCallProtectedApi: true
-        })).toBe(false);
-        expect(shouldSkipDataVersionPolling({
-            isOpen: false,
-            authBlocked: false,
-            authRequiredForApi: false,
-            isAuthenticated: false,
-            canCallProtectedApi: true
-        })).toBe(true);
-    });
-    it('skips data-version tick checks until auth gate conditions are satisfied', () => {
-        expect(shouldSkipDataVersionTick({
-            shouldGateProtectedApiCalls: true,
-            authSessionResolved: false,
-            authRequiredForApi: false,
-            isAuthenticated: false
-        })).toBe(true);
-        expect(shouldSkipDataVersionTick({
-            shouldGateProtectedApiCalls: true,
-            authSessionResolved: true,
-            authRequiredForApi: true,
-            isAuthenticated: false
-        })).toBe(true);
-        expect(shouldSkipDataVersionTick({
-            shouldGateProtectedApiCalls: true,
-            authSessionResolved: true,
-            authRequiredForApi: true,
-            isAuthenticated: true
-        })).toBe(false);
-    });
-});

package/dist/hooks/bootstrapTimeouts.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/bootstrapTimeouts.test.js

@@ -1,12 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AUTH_SESSION_REQUEST_TIMEOUT_MS, BOOTSTRAP_REQUEST_TIMEOUT_MS, CLOUD_BOOTSTRAP_REQUEST_TIMEOUT_MS, resolveBootstrapRequestTimeoutMs } from './bootstrapTimeouts';
-describe('bootstrap timeout budgets', () => {
-    it('keeps local bootstrap checks short', () => {
-        expect(resolveBootstrapRequestTimeoutMs('local')).toBe(BOOTSTRAP_REQUEST_TIMEOUT_MS);
-    });
-    it('gives cloud bootstrap checks enough room for edge delays', () => {
-        expect(resolveBootstrapRequestTimeoutMs('cloud')).toBe(CLOUD_BOOTSTRAP_REQUEST_TIMEOUT_MS);
-        expect(CLOUD_BOOTSTRAP_REQUEST_TIMEOUT_MS).toBeGreaterThan(BOOTSTRAP_REQUEST_TIMEOUT_MS);
-        expect(AUTH_SESSION_REQUEST_TIMEOUT_MS).toBeGreaterThan(BOOTSTRAP_REQUEST_TIMEOUT_MS);
-    });
-});

package/dist/hooks/sync/controlPlane.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/sync/controlPlane.test.js

@@ -1,121 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createWorkspaceSyncLeaseHeldDecision, resolvePullSyncReadiness, resolvePushSyncReadiness, resolveRetrySyncReadiness, } from './controlPlane';
-const makeBaseArgs = () => ({
-    cloudAuthConfigured: true,
-    runtimeMode: 'local',
-    workspaceCloudSyncEnabled: true,
-    currentWorkspaceId: 'workspace-123',
-    isAuthenticated: true
-});
-describe('sync control plane', () => {
-    it('blocks push during repair and retains the pending signature', () => {
-        expect(resolvePushSyncReadiness({
-            ...makeBaseArgs(),
-            workspaceSyncPhase: 'active',
-            repairModeActive: true,
-            repairModeBypass: false,
-            pushInFlight: false,
-            pullInFlight: false
-        })).toEqual({
-            allowed: false,
-            reason: 'repair-active',
-            retainPendingSignature: true
-        });
-    });
-    it('allows repair push to bypass the repair-active gate', () => {
-        expect(resolvePushSyncReadiness({
-            ...makeBaseArgs(),
-            workspaceSyncPhase: 'active',
-            repairModeActive: true,
-            repairModeBypass: true,
-            pushInFlight: false,
-            pullInFlight: false
-        })).toEqual({ allowed: true });
-    });
-    it('blocks push during attach-cloud and retains the pending signature', () => {
-        expect(resolvePushSyncReadiness({
-            ...makeBaseArgs(),
-            workspaceSyncPhase: 'attach-cloud',
-            repairModeActive: false,
-            repairModeBypass: false,
-            pushInFlight: false,
-            pullInFlight: false
-        })).toEqual({
-            allowed: false,
-            reason: 'attach-cloud',
-            retainPendingSignature: true
-        });
-    });
-    it('blocks pull during provision-local', () => {
-        expect(resolvePullSyncReadiness({
-            ...makeBaseArgs(),
-            workspaceSyncPhase: 'provision-local',
-            repairModeActive: false,
-            repairModeBypass: false,
-            retryPending: false,
-            pushInFlight: false,
-            pullInFlight: false
-        })).toEqual({
-            allowed: false,
-            reason: 'provision-local',
-            retainPendingSignature: false
-        });
-    });
-    it('blocks pull when a retry is already pending', () => {
-        expect(resolvePullSyncReadiness({
-            ...makeBaseArgs(),
-            workspaceSyncPhase: 'active',
-            repairModeActive: false,
-            repairModeBypass: false,
-            retryPending: true,
-            pushInFlight: false,
-            pullInFlight: false
-        })).toEqual({
-            allowed: false,
-            reason: 'retry-pending',
-            retainPendingSignature: false
-        });
-    });
-    it('surfaces auth-required for retry readiness before the session is refreshed', () => {
-        expect(resolveRetrySyncReadiness({
-            ...makeBaseArgs(),
-            isAuthenticated: false
-        })).toEqual({
-            allowed: false,
-            reason: 'auth-required',
-            retainPendingSignature: false
-        });
-    });
-    it('rejects invalid workspace ids for transfer operations', () => {
-        expect(resolvePushSyncReadiness({
-            ...makeBaseArgs(),
-            currentWorkspaceId: 'default',
-            workspaceSyncPhase: 'active',
-            repairModeActive: false,
-            repairModeBypass: false,
-            pushInFlight: false,
-            pullInFlight: false
-        })).toEqual({
-            allowed: false,
-            reason: 'invalid-workspace',
-            retainPendingSignature: false
-        });
-    });
-    it('marks lease contention as retaining the pending signature only for push', () => {
-        expect(createWorkspaceSyncLeaseHeldDecision('push')).toEqual({
-            allowed: false,
-            reason: 'lease-held',
-            retainPendingSignature: true
-        });
-        expect(createWorkspaceSyncLeaseHeldDecision('pull')).toEqual({
-            allowed: false,
-            reason: 'lease-held',
-            retainPendingSignature: false
-        });
-        expect(createWorkspaceSyncLeaseHeldDecision('repair')).toEqual({
-            allowed: false,
-            reason: 'lease-held',
-            retainPendingSignature: false
-        });
-    });
-});

package/dist/hooks/sync/lifecyclePolicy.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/sync/lifecyclePolicy.test.js

@@ -1,124 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveWorkspaceAutomaticPullPolicy, resolveWorkspaceSyncPresentation, shouldRunWorkspaceStartupRepair, shouldScheduleWorkspaceReactivePush, shouldStartWorkspacePeriodicFullReconcile, shouldStartWorkspacePushWatchdog, } from './lifecyclePolicy';
-const makeLifecycleBaseArgs = () => ({
-    cloudAuthConfigured: true,
-    runtimeMode: 'local',
-    workspaceCloudSyncEnabled: true,
-    authSessionResolved: true
-});
-describe('sync lifecycle policy', () => {
-    it('reports bootstrap phases as syncing with phase-specific guidance', () => {
-        expect(resolveWorkspaceSyncPresentation({
-            enabled: true,
-            phase: 'attach-cloud',
-            busy: false,
-            retryAt: null,
-            lastErrorMessage: null
-        })).toEqual({
-            status: 'syncing',
-            summary: 'Waiting for the first cloud pull into this device.',
-            recommendedAction: 'Keep this window open for the first cloud pull. If it does not move, press Repair.'
-        });
-    });
-    it('reports retry state as attention even when sync is otherwise idle', () => {
-        expect(resolveWorkspaceSyncPresentation({
-            enabled: true,
-            phase: 'active',
-            busy: false,
-            retryAt: '2026-04-18T16:00:00.000Z',
-            lastErrorMessage: null
-        })).toEqual({
-            status: 'attention',
-            summary: 'Sync hit a temporary problem and will retry automatically.',
-            recommendedAction: 'Wait for the automatic retry, or press Sync to retry now.'
-        });
-    });
-    it('allows reactive push only after bootstrap and reference snapshots are ready', () => {
-        expect(shouldScheduleWorkspaceReactivePush({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'active',
-            workspaceSyncReferenceSnapshotsReady: true
-        })).toBe(true);
-        expect(shouldScheduleWorkspaceReactivePush({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'attach-cloud',
-            workspaceSyncReferenceSnapshotsReady: true
-        })).toBe(false);
-        expect(shouldScheduleWorkspaceReactivePush({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'active',
-            workspaceSyncReferenceSnapshotsReady: false
-        })).toBe(false);
-    });
-    it('starts the push watchdog only for active sync', () => {
-        expect(shouldStartWorkspacePushWatchdog({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'active',
-            workspaceSyncReferenceSnapshotsReady: true
-        })).toBe(true);
-        expect(shouldStartWorkspacePushWatchdog({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'error',
-            workspaceSyncReferenceSnapshotsReady: true
-        })).toBe(false);
-    });
-    it('starts automatic pull for attach-cloud and kickstarts first active pull when no pull has succeeded yet', () => {
-        expect(resolveWorkspaceAutomaticPullPolicy({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'attach-cloud',
-            lastPullAt: null,
-            retryPending: false
-        })).toEqual({
-            shouldStart: true,
-            shouldKickOffImmediately: true
-        });
-        expect(resolveWorkspaceAutomaticPullPolicy({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'active',
-            lastPullAt: null,
-            retryPending: false
-        })).toEqual({
-            shouldStart: true,
-            shouldKickOffImmediately: true
-        });
-        expect(resolveWorkspaceAutomaticPullPolicy({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'active',
-            lastPullAt: '2026-04-18T15:00:00.000Z',
-            retryPending: true
-        })).toEqual({
-            shouldStart: false,
-            shouldKickOffImmediately: false
-        });
-    });
-    it('runs periodic full reconcile and startup repair only in authenticated active sync', () => {
-        expect(shouldStartWorkspacePeriodicFullReconcile({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'active',
-            isAuthenticated: true
-        })).toBe(true);
-        expect(shouldStartWorkspacePeriodicFullReconcile({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'attach-cloud',
-            isAuthenticated: true
-        })).toBe(false);
-        expect(shouldRunWorkspaceStartupRepair({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'active',
-            isAuthenticated: true,
-            alreadyRan: false
-        })).toBe(true);
-        expect(shouldRunWorkspaceStartupRepair({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'error',
-            isAuthenticated: true,
-            alreadyRan: false
-        })).toBe(true);
-        expect(shouldRunWorkspaceStartupRepair({
-            ...makeLifecycleBaseArgs(),
-            workspaceSyncPhase: 'active',
-            isAuthenticated: true,
-            alreadyRan: true
-        })).toBe(false);
-    });
-});

package/dist/hooks/sync/orchestratorShared.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/sync/orchestratorShared.test.js

@@ -1,98 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { readPersistedSyncWatermarks, savePersistedSyncWatermarks, WORKSPACE_SYNC_WATERMARKS_KEY_PREFIX, } from './orchestratorShared';
-describe('orchestratorShared sync watermarks', () => {
-    const workspaceId = 'workspace-local-active';
-    beforeEach(() => {
-        localStorage.clear();
-    });
-    it('keeps persisted sync watermarks available across long idle periods', () => {
-        const key = `${WORKSPACE_SYNC_WATERMARKS_KEY_PREFIX}.${workspaceId}`;
-        localStorage.setItem(key, JSON.stringify({
-            v: 9,
-            savedAt: '2026-04-14T10:00:00.000Z',
-            taskIds: ['task-1'],
-            taskWatermarks: [['task-1', '2026-04-14T09:00:00.000Z']],
-            initiativeWatermarks: [['initiative-1', '2026-04-14T09:00:00.000Z']],
-            workstreamWatermarks: [],
-            aiProfileWatermarks: [['ai-profile-1', '2026-04-14T09:15:00.000Z']],
-            documentWatermarks: [],
-            assetWatermarks: [],
-            documentReviewSessionWatermarks: [],
-            documentReviewCommentWatermarks: [],
-            annotatedAttachmentSessionWatermarks: [],
-            taskEventWatermarks: [['event-1', '2026-04-14T09:30:00.000Z']],
-            taxonomyStateFingerprint: ''
-        }));
-        const persisted = readPersistedSyncWatermarks(workspaceId, '');
-        expect(persisted).not.toBeNull();
-        expect(Array.from(persisted?.taskIds || [])).toEqual(['task-1']);
-        expect(persisted?.taskWatermarks.get('task-1')).toBe('2026-04-14T09:00:00.000Z');
-        expect(persisted?.initiativeWatermarks.get('initiative-1')).toBe('2026-04-14T09:00:00.000Z');
-        expect(persisted?.aiProfileWatermarks.get('ai-profile-1')).toBe('2026-04-14T09:15:00.000Z');
-        expect(persisted?.taskEventWatermarks.get('event-1')).toBe('2026-04-14T09:30:00.000Z');
-    });
-    it('persists task and ai-profile change keys alongside legacy watermarks', () => {
-        savePersistedSyncWatermarks(workspaceId, {
-            taskIds: new Set(['task-1']),
-            taskWatermarks: new Map([['task-1', '2026-04-14T09:00:00.000Z']]),
-            taskChangeKeys: new Map([['task-1', 'task-change-key-1']]),
-            initiativeWatermarks: new Map(),
-            workstreamWatermarks: new Map(),
-            aiProfileWatermarks: new Map([['ai-profile-1', '2026-04-14T09:15:00.000Z']]),
-            aiProfileChangeKeys: new Map([['ai-profile-1', 'ai-change-key-1']]),
-            documentWatermarks: new Map(),
-            assetWatermarks: new Map(),
-            documentReviewSessionWatermarks: new Map(),
-            documentReviewCommentWatermarks: new Map(),
-            annotatedAttachmentSessionWatermarks: new Map(),
-            taskEventWatermarks: new Map(),
-            taxonomyStateFingerprint: 'fingerprint-a'
-        });
-        const persisted = readPersistedSyncWatermarks(workspaceId, 'fingerprint-a');
-        expect(persisted?.taskChangeKeys?.get('task-1')).toBe('task-change-key-1');
-        expect(persisted?.aiProfileChangeKeys?.get('ai-profile-1')).toBe('ai-change-key-1');
-    });
-    it('still clears task watermarks when the taxonomy fingerprint changes', () => {
-        savePersistedSyncWatermarks(workspaceId, {
-            taskIds: new Set(['task-1']),
-            taskWatermarks: new Map([['task-1', '2026-04-14T09:00:00.000Z']]),
-            initiativeWatermarks: new Map([['initiative-1', '2026-04-14T09:00:00.000Z']]),
-            workstreamWatermarks: new Map(),
-            aiProfileWatermarks: new Map([['ai-profile-1', '2026-04-14T09:15:00.000Z']]),
-            documentWatermarks: new Map(),
-            assetWatermarks: new Map(),
-            documentReviewSessionWatermarks: new Map(),
-            documentReviewCommentWatermarks: new Map(),
-            annotatedAttachmentSessionWatermarks: new Map(),
-            taskEventWatermarks: new Map([['event-1', '2026-04-14T09:30:00.000Z']]),
-            taxonomyStateFingerprint: 'fingerprint-a'
-        });
-        const persisted = readPersistedSyncWatermarks(workspaceId, 'fingerprint-b');
-        expect(persisted).not.toBeNull();
-        expect(Array.from(persisted?.taskIds || [])).toEqual(['task-1']);
-        expect(persisted?.taskWatermarks.size).toBe(0);
-        expect(persisted?.initiativeWatermarks.get('initiative-1')).toBe('2026-04-14T09:00:00.000Z');
-        expect(persisted?.aiProfileWatermarks.get('ai-profile-1')).toBe('2026-04-14T09:15:00.000Z');
-        expect(persisted?.taskEventWatermarks.get('event-1')).toBe('2026-04-14T09:30:00.000Z');
-    });
-    it('falls back to task watermark keys when older persisted snapshots do not have taskIds', () => {
-        const key = `${WORKSPACE_SYNC_WATERMARKS_KEY_PREFIX}.${workspaceId}`;
-        localStorage.setItem(key, JSON.stringify({
-            v: 9,
-            savedAt: '2026-04-14T10:00:00.000Z',
-            taskWatermarks: [['task-legacy-1', '2026-04-14T09:00:00.000Z']],
-            initiativeWatermarks: [],
-            workstreamWatermarks: [],
-            aiProfileWatermarks: [],
-            documentWatermarks: [],
-            assetWatermarks: [],
-            documentReviewSessionWatermarks: [],
-            documentReviewCommentWatermarks: [],
-            annotatedAttachmentSessionWatermarks: [],
-            taskEventWatermarks: [],
-            taxonomyStateFingerprint: ''
-        }));
-        const persisted = readPersistedSyncWatermarks(workspaceId, '');
-        expect(Array.from(persisted?.taskIds || [])).toEqual(['task-legacy-1']);
-    });
-});

package/dist/hooks/sync/pullLifecycle.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/sync/pullLifecycle.test.js

@@ -1,80 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveWorkspacePullRequestPlan, resolveWorkspacePullSuccessPlan, } from './pullLifecycle';
-describe('pull lifecycle', () => {
-    it('treats attach-cloud pulls as bootstrap pulls with a null cursor', () => {
-        expect(resolveWorkspacePullRequestPlan({
-            workspaceSyncPhase: 'attach-cloud',
-            forceCursorNull: false,
-            currentCursor: 'cursor-1'
-        })).toEqual({
-            bootstrap: true,
-            cursor: null,
-            successEventType: 'bootstrap'
-        });
-    });
-    it('keeps the saved cursor for normal incremental pulls', () => {
-        expect(resolveWorkspacePullRequestPlan({
-            workspaceSyncPhase: 'active',
-            forceCursorNull: false,
-            currentCursor: 'cursor-1'
-        })).toEqual({
-            bootstrap: false,
-            cursor: 'cursor-1',
-            successEventType: 'pull'
-        });
-    });
-    it('marks attach-cloud success for reference refresh and baseline seeding without a follow-up push', () => {
-        expect(resolveWorkspacePullSuccessPlan({
-            workspaceSyncPhase: 'attach-cloud',
-            forceCursorNull: false,
-            startupFullReconcileRan: false,
-            pendingSignature: 'sig-pending',
-            fallbackSignature: 'sig-fallback',
-            lastPushedSignature: ''
-        })).toEqual({
-            successEventType: 'bootstrap',
-            shouldCaptureAttachBootstrapBaseline: true,
-            shouldClearPendingSignature: true,
-            shouldRefreshReferenceSnapshots: true,
-            shouldSeedWorkspaceSnapshotPushBaseline: true,
-            shouldScheduleStartupFullReconcile: false,
-            deferredPushSignature: null
-        });
-    });
-    it('schedules a one-time startup full reconcile and deferred push after the first normal pull', () => {
-        expect(resolveWorkspacePullSuccessPlan({
-            workspaceSyncPhase: 'active',
-            forceCursorNull: false,
-            startupFullReconcileRan: false,
-            pendingSignature: 'sig-pending',
-            fallbackSignature: 'sig-fallback',
-            lastPushedSignature: 'sig-old'
-        })).toEqual({
-            successEventType: 'pull',
-            shouldCaptureAttachBootstrapBaseline: false,
-            shouldClearPendingSignature: true,
-            shouldRefreshReferenceSnapshots: false,
-            shouldSeedWorkspaceSnapshotPushBaseline: false,
-            shouldScheduleStartupFullReconcile: true,
-            deferredPushSignature: 'sig-pending'
-        });
-    });
-    it('does not schedule a second startup full reconcile or redundant deferred push', () => {
-        expect(resolveWorkspacePullSuccessPlan({
-            workspaceSyncPhase: 'active',
-            forceCursorNull: true,
-            startupFullReconcileRan: true,
-            pendingSignature: '',
-            fallbackSignature: 'sig-current',
-            lastPushedSignature: 'sig-current'
-        })).toEqual({
-            successEventType: 'pull',
-            shouldCaptureAttachBootstrapBaseline: false,
-            shouldClearPendingSignature: false,
-            shouldRefreshReferenceSnapshots: false,
-            shouldSeedWorkspaceSnapshotPushBaseline: false,
-            shouldScheduleStartupFullReconcile: false,
-            deferredPushSignature: null
-        });
-    });
-});

package/dist/hooks/sync/recovery.test.d.ts

@@ -1 +0,0 @@
-export {};