@taskforcehq/taskforce 0.3.326 → 0.3.327

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

@@ -1,37 +1 @@
-import type { WorkspaceSyncPhase } from '../../sync/workspaceSyncState';
-export type WorkspaceSyncBlockedReason = 'cloud-auth-unconfigured' | 'runtime-not-local' | 'sync-disabled' | 'invalid-workspace' | 'repair-active' | 'attach-cloud' | 'provision-local' | 'auth-required' | 'push-in-flight' | 'pull-in-flight' | 'retry-pending' | 'lease-held';
-export type WorkspaceSyncOperation = 'pull' | 'push' | 'repair';
-export type WorkspaceSyncControlPlaneDecision = {
-    allowed: true;
-} | {
-    allowed: false;
-    reason: WorkspaceSyncBlockedReason;
-    retainPendingSignature: boolean;
-};
-interface WorkspaceSyncControlPlaneBaseArgs {
-    cloudAuthConfigured: boolean;
-    runtimeMode: 'local' | 'cloud';
-    workspaceCloudSyncEnabled: boolean;
-    currentWorkspaceId: string;
-    isAuthenticated: boolean;
-}
-interface PushSyncReadinessArgs extends WorkspaceSyncControlPlaneBaseArgs {
-    workspaceSyncPhase: WorkspaceSyncPhase;
-    repairModeActive: boolean;
-    repairModeBypass: boolean;
-    pushInFlight: boolean;
-    pullInFlight: boolean;
-}
-interface PullSyncReadinessArgs extends WorkspaceSyncControlPlaneBaseArgs {
-    workspaceSyncPhase: WorkspaceSyncPhase;
-    repairModeActive: boolean;
-    repairModeBypass: boolean;
-    retryPending: boolean;
-    pushInFlight: boolean;
-    pullInFlight: boolean;
-}
-export declare function resolvePushSyncReadiness(args: PushSyncReadinessArgs): WorkspaceSyncControlPlaneDecision;
-export declare function resolvePullSyncReadiness(args: PullSyncReadinessArgs): WorkspaceSyncControlPlaneDecision;
-export declare function resolveRetrySyncReadiness(args: WorkspaceSyncControlPlaneBaseArgs): WorkspaceSyncControlPlaneDecision;
-export declare function createWorkspaceSyncLeaseHeldDecision(operation: WorkspaceSyncOperation): WorkspaceSyncControlPlaneDecision;
-export {};
+export * from '../../sync/engine/workspaceSyncEngineControlPlane.js';

package/dist/hooks/sync/controlPlane.js

@@ -1,78 +1 @@
-import { isValidWorkspaceKey } from './orchestratorShared';
-const ALLOW_SYNC_OPERATION = { allowed: true };
-function blockSyncOperation(reason, options) {
-    return {
-        allowed: false,
-        reason,
-        retainPendingSignature: options?.retainPendingSignature === true
-    };
-}
-function resolveBaseSyncReadiness(args, options) {
-    if (!args.cloudAuthConfigured)
-        return blockSyncOperation('cloud-auth-unconfigured');
-    if (args.runtimeMode !== 'local')
-        return blockSyncOperation('runtime-not-local');
-    if (!args.workspaceCloudSyncEnabled)
-        return blockSyncOperation('sync-disabled');
-    if ((options?.requireValidWorkspace ?? true) && !isValidWorkspaceKey(args.currentWorkspaceId)) {
-        return blockSyncOperation('invalid-workspace');
-    }
-    return null;
-}
-export function resolvePushSyncReadiness(args) {
-    const baseReadiness = resolveBaseSyncReadiness(args);
-    if (baseReadiness)
-        return baseReadiness;
-    if (args.repairModeActive && !args.repairModeBypass) {
-        return blockSyncOperation('repair-active', { retainPendingSignature: true });
-    }
-    if (args.workspaceSyncPhase === 'attach-cloud') {
-        return blockSyncOperation('attach-cloud', { retainPendingSignature: true });
-    }
-    if (!args.isAuthenticated) {
-        return blockSyncOperation('auth-required');
-    }
-    if (args.pushInFlight) {
-        return blockSyncOperation('push-in-flight', { retainPendingSignature: true });
-    }
-    if (args.pullInFlight) {
-        return blockSyncOperation('pull-in-flight', { retainPendingSignature: true });
-    }
-    return ALLOW_SYNC_OPERATION;
-}
-export function resolvePullSyncReadiness(args) {
-    const baseReadiness = resolveBaseSyncReadiness(args);
-    if (baseReadiness)
-        return baseReadiness;
-    if (args.repairModeActive && !args.repairModeBypass) {
-        return blockSyncOperation('repair-active');
-    }
-    if (args.workspaceSyncPhase === 'provision-local') {
-        return blockSyncOperation('provision-local');
-    }
-    if (args.retryPending) {
-        return blockSyncOperation('retry-pending');
-    }
-    if (!args.isAuthenticated) {
-        return blockSyncOperation('auth-required');
-    }
-    if (args.pullInFlight) {
-        return blockSyncOperation('pull-in-flight');
-    }
-    if (args.pushInFlight) {
-        return blockSyncOperation('push-in-flight');
-    }
-    return ALLOW_SYNC_OPERATION;
-}
-export function resolveRetrySyncReadiness(args) {
-    const baseReadiness = resolveBaseSyncReadiness(args, { requireValidWorkspace: false });
-    if (baseReadiness)
-        return baseReadiness;
-    if (!args.isAuthenticated) {
-        return blockSyncOperation('auth-required');
-    }
-    return ALLOW_SYNC_OPERATION;
-}
-export function createWorkspaceSyncLeaseHeldDecision(operation) {
-    return blockSyncOperation('lease-held', { retainPendingSignature: operation === 'push' });
-}
+export * from '../../sync/engine/workspaceSyncEngineControlPlane.js';

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

@@ -1,45 +1 @@
-import type { WorkspaceSyncPhase } from '../../sync/workspaceSyncState';
-export type WorkspaceSyncPresentationStatus = 'off' | 'syncing' | 'attention' | 'healthy';
-interface WorkspaceSyncPresentationArgs {
-    enabled: boolean;
-    phase: WorkspaceSyncPhase;
-    busy: boolean;
-    retryAt: string | null;
-    lastErrorMessage: string | null;
-}
-interface WorkspaceSyncLifecycleBaseArgs {
-    cloudAuthConfigured: boolean;
-    runtimeMode: 'local' | 'cloud';
-    workspaceCloudSyncEnabled: boolean;
-    authSessionResolved: boolean;
-}
-interface WorkspaceSyncAutomaticPullArgs extends WorkspaceSyncLifecycleBaseArgs {
-    workspaceSyncPhase: WorkspaceSyncPhase;
-    lastPullAt: string | null;
-    retryPending: boolean;
-}
-interface WorkspaceSyncFullReconcileArgs extends WorkspaceSyncLifecycleBaseArgs {
-    workspaceSyncPhase: WorkspaceSyncPhase;
-    isAuthenticated: boolean;
-}
-interface WorkspaceSyncStartupRepairArgs extends WorkspaceSyncFullReconcileArgs {
-    alreadyRan: boolean;
-}
-interface WorkspaceSyncReactivePushArgs extends WorkspaceSyncLifecycleBaseArgs {
-    workspaceSyncPhase: WorkspaceSyncPhase;
-    workspaceSyncReferenceSnapshotsReady: boolean;
-}
-export declare function resolveWorkspaceSyncPresentation({ enabled, phase, busy, retryAt, lastErrorMessage }: WorkspaceSyncPresentationArgs): {
-    status: WorkspaceSyncPresentationStatus;
-    summary: string;
-    recommendedAction: string;
-};
-export declare function shouldScheduleWorkspaceReactivePush(args: WorkspaceSyncReactivePushArgs): boolean;
-export declare function shouldStartWorkspacePushWatchdog(args: WorkspaceSyncReactivePushArgs): boolean;
-export declare function resolveWorkspaceAutomaticPullPolicy(args: WorkspaceSyncAutomaticPullArgs): {
-    shouldStart: boolean;
-    shouldKickOffImmediately: boolean;
-};
-export declare function shouldStartWorkspacePeriodicFullReconcile(args: WorkspaceSyncFullReconcileArgs): boolean;
-export declare function shouldRunWorkspaceStartupRepair(args: WorkspaceSyncStartupRepairArgs): boolean;
-export {};
+export * from '../../sync/engine/workspaceSyncEngineLifecyclePolicy.js';

package/dist/hooks/sync/lifecyclePolicy.js

@@ -1,93 +1 @@
-function canRunLocalWorkspaceSyncLifecycle(args) {
-    return args.cloudAuthConfigured
-        && args.runtimeMode === 'local'
-        && args.workspaceCloudSyncEnabled
-        && args.authSessionResolved;
-}
-export function resolveWorkspaceSyncPresentation({ enabled, phase, busy, retryAt, lastErrorMessage }) {
-    if (!enabled) {
-        return {
-            status: 'off',
-            summary: 'Sync is turned off for this workspace.',
-            recommendedAction: 'Turn on sync when you are ready to back up this workspace.'
-        };
-    }
-    if (phase === 'provision-local') {
-        return {
-            status: 'syncing',
-            summary: busy
-                ? 'Uploading this workspace to cloud for the first time.'
-                : 'Preparing the first upload to cloud.',
-            recommendedAction: 'Keep this window open while the first upload finishes. If it seems stalled, press Sync.'
-        };
-    }
-    if (phase === 'attach-cloud') {
-        return {
-            status: 'syncing',
-            summary: busy
-                ? 'Pulling the cloud workspace into this device.'
-                : '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.'
-        };
-    }
-    if (retryAt) {
-        return {
-            status: 'attention',
-            summary: 'Sync hit a temporary problem and will retry automatically.',
-            recommendedAction: 'Wait for the automatic retry, or press Sync to retry now.'
-        };
-    }
-    if (lastErrorMessage || phase === 'error') {
-        return {
-            status: 'attention',
-            summary: 'Sync needs attention before it can continue.',
-            recommendedAction: 'Press Sync to retry. If the same error keeps returning, press Repair.'
-        };
-    }
-    if (busy) {
-        return {
-            status: 'syncing',
-            summary: 'Sync is currently running.',
-            recommendedAction: 'No action needed.'
-        };
-    }
-    return {
-        status: 'healthy',
-        summary: 'Sync is healthy.',
-        recommendedAction: 'No action needed.'
-    };
-}
-export function shouldScheduleWorkspaceReactivePush(args) {
-    return canRunLocalWorkspaceSyncLifecycle(args)
-        && args.workspaceSyncPhase !== 'attach-cloud'
-        && args.workspaceSyncReferenceSnapshotsReady;
-}
-export function shouldStartWorkspacePushWatchdog(args) {
-    return canRunLocalWorkspaceSyncLifecycle(args)
-        && args.workspaceSyncPhase === 'active'
-        && args.workspaceSyncReferenceSnapshotsReady;
-}
-export function resolveWorkspaceAutomaticPullPolicy(args) {
-    if (!canRunLocalWorkspaceSyncLifecycle(args)) {
-        return { shouldStart: false, shouldKickOffImmediately: false };
-    }
-    if (args.workspaceSyncPhase === 'provision-local' || args.workspaceSyncPhase === 'error' || args.retryPending) {
-        return { shouldStart: false, shouldKickOffImmediately: false };
-    }
-    return {
-        shouldStart: true,
-        shouldKickOffImmediately: args.workspaceSyncPhase === 'attach-cloud' || !args.lastPullAt
-    };
-}
-export function shouldStartWorkspacePeriodicFullReconcile(args) {
-    return canRunLocalWorkspaceSyncLifecycle(args)
-        && args.isAuthenticated
-        && args.workspaceSyncPhase === 'active';
-}
-export function shouldRunWorkspaceStartupRepair(args) {
-    return canRunLocalWorkspaceSyncLifecycle(args)
-        && args.isAuthenticated
-        && args.workspaceSyncPhase !== 'provision-local'
-        && args.workspaceSyncPhase !== 'attach-cloud'
-        && !args.alreadyRan;
-}
+export * from '../../sync/engine/workspaceSyncEngineLifecyclePolicy.js';

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

@@ -1,7 +1,7 @@
 import type { WorkspaceTaxonomyState } from '../../shared/taxonomyState.js';
-import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncEntityEventSnapshot } from '../../sync/workspaceSyncModel';
+import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAgentConversationSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncTaskforceAgentSnapshot } from '../../sync/workspaceSyncModel';
 import type { WorkspaceSyncPushBaselineSnapshot } from '../../sync/workspaceSyncState.js';
-import type { InitiativeItem, TaskItem, WorkstreamItem } from '../../types';
+export { flattenTaskEvents } from '../../sync/workspaceSyncSnapshotProjection.js';
 export declare const USER_GLOBAL_SYNC_META_KEY = "taskforce.userGlobalSyncMeta.v1";
 export declare const SYNC_DEBUG_LOG_KEY = "taskforce.syncDebug.v1";
 export declare const WORKSPACE_BOOTSTRAP_TIMEOUT_MS = 120000;
@@ -11,6 +11,8 @@ export declare const WORKSPACE_CONCURRENT_WINDOW_MESSAGE = "Another local window
 export declare function isValidWorkspaceKey(workspaceId: string): boolean;
 export declare function logSyncDebug(event: string, details?: Record<string, unknown>): void;
 export declare function normalizeWorkspaceSyncAiProfileSnapshotEntry(entry: any): WorkspaceSyncAiProfileSnapshot;
+export declare function normalizeWorkspaceSyncTaskforceAgentSnapshotEntry(entry: any): WorkspaceSyncTaskforceAgentSnapshot;
+export declare function normalizeWorkspaceSyncAgentConversationSnapshotEntry(entry: any): WorkspaceSyncAgentConversationSnapshot;
 export declare function readUserGlobalSyncMeta(): Record<string, {
     updatedAt: string;
 }>;
@@ -19,21 +21,25 @@ export declare function writeUserGlobalSyncMeta(next: Record<string, {
 }>): void;
 export declare function buildTaxonomyStateFingerprint(taxonomyState?: WorkspaceTaxonomyState): string;
 export declare function flattenDocumentReviewComments(sessions: WorkspaceSyncDocumentReviewSessionSnapshot[]): WorkspaceSyncDocumentReviewCommentSnapshot[];
-export declare function flattenTaskEvents(tasks: TaskItem[], archivedTasks: TaskItem[], initiatives?: InitiativeItem[], workstreams?: WorkstreamItem[]): WorkspaceSyncEntityEventSnapshot[];
 export interface PersistedSyncWatermarks {
     taskIds: Set<string>;
     taskWatermarks: Map<string, string>;
     taskChangeKeys?: Map<string, string>;
+    taskRelationshipChangeKeys?: Map<string, string>;
     initiativeWatermarks: Map<string, string>;
     workstreamWatermarks: Map<string, string>;
     aiProfileWatermarks: Map<string, string>;
     aiProfileChangeKeys?: Map<string, string>;
+    taskforceAgentWatermarks?: Map<string, string>;
+    taskforceAgentSkillWatermarks?: Map<string, string>;
+    agentConversationWatermarks?: Map<string, string>;
     documentWatermarks: Map<string, string>;
     assetWatermarks: Map<string, string>;
     documentReviewSessionWatermarks: Map<string, string>;
     documentReviewCommentWatermarks: Map<string, string>;
     annotatedAttachmentSessionWatermarks: Map<string, string>;
     taskEventWatermarks: Map<string, string>;
+    taxonomyChangeKey?: string;
 }
 export declare function buildPersistedSyncWatermarksSnapshot(data: PersistedSyncWatermarks & {
     taxonomyStateFingerprint?: string;

package/dist/hooks/sync/orchestratorShared.js

@@ -1,6 +1,8 @@
 import { parseAiProfileSurfaceType } from '../../shared/aiProfileSurfaceType.js';
 import { parseAiProfileSeatScope } from '../../shared/aiProfileSeatScope.js';
 import { normalizeSyncNullableId, normalizeSyncNullableIsoString, normalizeSyncNullableString, normalizeSyncSameOriginAssetUrl, } from '../../sync/syncFieldSemantics.js';
+import { normalizeTaskforceAgentModelKey, normalizeTaskforceAgentProviderKey, } from '../../shared/taskforceAgentModels.js';
+export { flattenTaskEvents } from '../../sync/workspaceSyncSnapshotProjection.js';
 export const USER_GLOBAL_SYNC_META_KEY = 'taskforce.userGlobalSyncMeta.v1';
 export const SYNC_DEBUG_LOG_KEY = 'taskforce.syncDebug.v1';
 export const WORKSPACE_BOOTSTRAP_TIMEOUT_MS = 120_000;
@@ -61,6 +63,59 @@ export function normalizeWorkspaceSyncAiProfileSnapshotEntry(entry) {
         lastActiveAt: normalizeSyncNullableIsoString(entry?.lastActiveAt ?? entry?.last_active_at)
     };
 }
+export function normalizeWorkspaceSyncTaskforceAgentSnapshotEntry(entry) {
+    const tier = String(entry?.modelTier || entry?.model_tier || '').trim().toLowerCase();
+    return {
+        id: String(entry?.id || '').trim(),
+        tenantId: String(entry?.tenantId || entry?.tenant_id || '').trim() || undefined,
+        workspaceId: String(entry?.workspaceId || entry?.workspace_id || '').trim(),
+        name: String(entry?.name || 'Agent').trim() || 'Agent',
+        modelProvider: 'taskforce_hq',
+        providerKey: normalizeTaskforceAgentProviderKey(entry?.providerKey ?? entry?.provider_key),
+        modelKey: normalizeTaskforceAgentModelKey(entry?.modelKey ?? entry?.model_key, entry?.providerKey ?? entry?.provider_key),
+        modelTier: tier === 'fast' || tier === 'advanced' ? tier : 'balanced',
+        systemPrompt: typeof (entry?.systemPrompt ?? entry?.system_prompt) === 'string'
+            ? String(entry?.systemPrompt ?? entry?.system_prompt)
+            : '',
+        enabled: (entry?.enabled ?? true) !== false && Number(entry?.enabled ?? 1) !== 0,
+        createdByUserId: normalizeSyncNullableId(entry?.createdByUserId ?? entry?.created_by_user_id),
+        updatedByUserId: normalizeSyncNullableId(entry?.updatedByUserId ?? entry?.updated_by_user_id),
+        createdAt: String(entry?.createdAt || entry?.created_at || '').trim(),
+        updatedAt: String(entry?.updatedAt || entry?.updated_at || entry?.createdAt || entry?.created_at || '').trim(),
+        deletedAt: normalizeSyncNullableIsoString(entry?.deletedAt ?? entry?.deleted_at),
+    };
+}
+export function normalizeWorkspaceSyncAgentConversationSnapshotEntry(entry) {
+    const messages = Array.isArray(entry?.messages)
+        ? entry.messages
+            .map((message) => ({
+            role: message?.role === 'assistant' ? 'assistant' : 'user',
+            content: String(message?.content || '').trim()
+        }))
+            .filter((message) => message.content.length > 0)
+        : [];
+    const usage = (entry?.usage ?? entry?.usage_json) && typeof (entry?.usage ?? entry?.usage_json) === 'object'
+        ? (entry?.usage ?? entry?.usage_json)
+        : null;
+    return {
+        id: String(entry?.id || '').trim(),
+        tenantId: String(entry?.tenantId || entry?.tenant_id || '').trim() || undefined,
+        workspaceId: String(entry?.workspaceId || entry?.workspace_id || '').trim(),
+        agentId: String(entry?.agentId || entry?.agent_id || '').trim(),
+        taskId: normalizeSyncNullableId(entry?.taskId ?? entry?.task_id),
+        title: String(entry?.title || 'Agent chat').trim() || 'Agent chat',
+        messages,
+        modelProvider: normalizeSyncNullableString(entry?.modelProvider ?? entry?.model_provider),
+        modelId: normalizeSyncNullableString(entry?.modelId ?? entry?.model_id),
+        usage,
+        latencyMs: Number.isFinite(Number(entry?.latencyMs ?? entry?.latency_ms)) ? Number(entry?.latencyMs ?? entry?.latency_ms) : null,
+        createdByUserId: normalizeSyncNullableId(entry?.createdByUserId ?? entry?.created_by_user_id),
+        updatedByUserId: normalizeSyncNullableId(entry?.updatedByUserId ?? entry?.updated_by_user_id),
+        createdAt: String(entry?.createdAt || entry?.created_at || '').trim(),
+        updatedAt: String(entry?.updatedAt || entry?.updated_at || entry?.createdAt || entry?.created_at || '').trim(),
+        deletedAt: normalizeSyncNullableIsoString(entry?.deletedAt ?? entry?.deleted_at),
+    };
+}
 export function readUserGlobalSyncMeta() {
     if (typeof window === 'undefined')
         return {};
@@ -108,6 +163,8 @@ export function flattenDocumentReviewComments(sessions) {
             anchor: comment?.anchor ?? null,
             order: Number.isFinite(Number(comment?.order)) ? Math.max(0, Math.floor(Number(comment.order))) : 0,
             authorActorId: typeof comment?.authorActorId === 'string' && comment.authorActorId.trim().length > 0 ? comment.authorActorId.trim() : null,
+            updatedByActorId: typeof comment?.updatedByActorId === 'string' && comment.updatedByActorId.trim().length > 0 ? comment.updatedByActorId.trim() : null,
+            deletedByActorId: typeof comment?.deletedByActorId === 'string' && comment.deletedByActorId.trim().length > 0 ? comment.deletedByActorId.trim() : null,
             createdAt: String(comment?.createdAt || '').trim(),
             updatedAt: String(comment?.updatedAt || comment?.createdAt || '').trim(),
             deletedAt: typeof comment?.deletedAt === 'string' && comment.deletedAt.trim().length > 0 ? comment.deletedAt.trim() : null,
@@ -115,115 +172,27 @@ export function flattenDocumentReviewComments(sessions) {
             .filter((comment) => comment.id.length > 0 && comment.sessionId.length > 0);
     });
 }
-export function flattenTaskEvents(tasks, archivedTasks, initiatives = [], workstreams = []) {
-    const deduped = new Map();
-    for (const task of [...(tasks || []), ...(archivedTasks || [])]) {
-        const taskEvents = Array.isArray(task?.taskEvents) ? task.taskEvents : [];
-        for (const event of taskEvents) {
-            const id = String(event?.id || '').trim();
-            const taskId = String(event?.taskId || task?.id || '').trim();
-            const workspaceId = String(event?.workspaceId || '').trim();
-            const createdAt = String(event?.createdAt || '').trim();
-            if (!id || !taskId || !workspaceId || !createdAt)
-                continue;
-            const nextEvent = {
-                id,
-                workspaceId,
-                entityType: 'task',
-                entityId: taskId,
-                taskId,
-                action: String(event?.action || '').trim(),
-                actor: String(event?.actor || 'system').trim() || 'system',
-                actorType: event?.actorType === 'ai' || event?.actorType === 'human' || event?.actorType === 'system'
-                    ? event.actorType
-                    : 'system',
-                details: event?.details,
-                createdAt,
-            };
-            const existing = deduped.get(id);
-            if (!existing || nextEvent.createdAt > existing.createdAt) {
-                deduped.set(id, nextEvent);
-            }
-        }
-    }
-    for (const initiative of initiatives || []) {
-        const entityEvents = Array.isArray(initiative?.entityEvents) ? initiative.entityEvents : [];
-        for (const event of entityEvents) {
-            const id = String(event?.id || '').trim();
-            const entityId = String(event?.entityId || initiative?.id || '').trim();
-            const workspaceId = String(event?.workspaceId || '').trim();
-            const createdAt = String(event?.createdAt || '').trim();
-            if (!id || !entityId || !workspaceId || !createdAt)
-                continue;
-            const nextEvent = {
-                id,
-                workspaceId,
-                entityType: 'initiative',
-                entityId,
-                action: String(event?.action || '').trim(),
-                actor: String(event?.actor || 'system').trim() || 'system',
-                actorType: event?.actorType === 'ai' || event?.actorType === 'human' || event?.actorType === 'system'
-                    ? event.actorType
-                    : 'system',
-                details: event?.details,
-                createdAt,
-            };
-            const existing = deduped.get(id);
-            if (!existing || nextEvent.createdAt > existing.createdAt) {
-                deduped.set(id, nextEvent);
-            }
-        }
-    }
-    for (const workstream of workstreams || []) {
-        const entityEvents = Array.isArray(workstream?.entityEvents) ? workstream.entityEvents : [];
-        for (const event of entityEvents) {
-            const id = String(event?.id || '').trim();
-            const entityId = String(event?.entityId || workstream?.id || '').trim();
-            const workspaceId = String(event?.workspaceId || '').trim();
-            const createdAt = String(event?.createdAt || '').trim();
-            if (!id || !entityId || !workspaceId || !createdAt)
-                continue;
-            const nextEvent = {
-                id,
-                workspaceId,
-                entityType: 'workstream',
-                entityId,
-                action: String(event?.action || '').trim(),
-                actor: String(event?.actor || 'system').trim() || 'system',
-                actorType: event?.actorType === 'ai' || event?.actorType === 'human' || event?.actorType === 'system'
-                    ? event.actorType
-                    : 'system',
-                details: event?.details,
-                createdAt,
-            };
-            const existing = deduped.get(id);
-            if (!existing || nextEvent.createdAt > existing.createdAt) {
-                deduped.set(id, nextEvent);
-            }
-        }
-    }
-    return Array.from(deduped.values()).sort((left, right) => {
-        if (left.createdAt !== right.createdAt)
-            return left.createdAt.localeCompare(right.createdAt);
-        return left.id.localeCompare(right.id);
-    });
-}
 export function buildPersistedSyncWatermarksSnapshot(data) {
     return {
         taskIds: Array.from(data.taskIds.values()),
         taskWatermarks: Array.from(data.taskWatermarks.entries()),
         taskChangeKeys: Array.from((data.taskChangeKeys || new Map()).entries()),
+        taskRelationshipChangeKeys: Array.from((data.taskRelationshipChangeKeys || new Map()).entries()),
         initiativeWatermarks: Array.from(data.initiativeWatermarks.entries()),
         workstreamWatermarks: Array.from(data.workstreamWatermarks.entries()),
         aiProfileWatermarks: Array.from(data.aiProfileWatermarks.entries()),
         aiProfileChangeKeys: Array.from((data.aiProfileChangeKeys || new Map()).entries()),
+        taskforceAgentWatermarks: Array.from((data.taskforceAgentWatermarks || new Map()).entries()),
+        taskforceAgentSkillWatermarks: Array.from((data.taskforceAgentSkillWatermarks || new Map()).entries()),
+        agentConversationWatermarks: Array.from((data.agentConversationWatermarks || new Map()).entries()),
         documentWatermarks: Array.from(data.documentWatermarks.entries()),
         assetWatermarks: Array.from(data.assetWatermarks.entries()),
         documentReviewSessionWatermarks: Array.from(data.documentReviewSessionWatermarks.entries()),
         documentReviewCommentWatermarks: Array.from(data.documentReviewCommentWatermarks.entries()),
         annotatedAttachmentSessionWatermarks: Array.from(data.annotatedAttachmentSessionWatermarks.entries()),
         taskEventWatermarks: Array.from(data.taskEventWatermarks.entries()),
-        taxonomyStateFingerprint: typeof data.taxonomyStateFingerprint === 'string' ? data.taxonomyStateFingerprint : ''
+        taxonomyStateFingerprint: typeof data.taxonomyStateFingerprint === 'string' ? data.taxonomyStateFingerprint : '',
+        taxonomyChangeKey: typeof data.taxonomyChangeKey === 'string' ? data.taxonomyChangeKey : ''
     };
 }
 export function parsePersistedSyncWatermarksSnapshot(snapshot, taxonomyStateFingerprint) {
@@ -242,16 +211,21 @@ export function parsePersistedSyncWatermarksSnapshot(snapshot, taxonomyStateFing
         taskIds,
         taskWatermarks,
         taskChangeKeys: new Map(Array.isArray(snapshot.taskChangeKeys) ? snapshot.taskChangeKeys : []),
+        taskRelationshipChangeKeys: new Map(Array.isArray(snapshot.taskRelationshipChangeKeys) ? snapshot.taskRelationshipChangeKeys : []),
         initiativeWatermarks: new Map(Array.isArray(snapshot.initiativeWatermarks) ? snapshot.initiativeWatermarks : []),
         workstreamWatermarks: new Map(Array.isArray(snapshot.workstreamWatermarks) ? snapshot.workstreamWatermarks : []),
         aiProfileWatermarks: new Map(Array.isArray(snapshot.aiProfileWatermarks) ? snapshot.aiProfileWatermarks : []),
         aiProfileChangeKeys: new Map(Array.isArray(snapshot.aiProfileChangeKeys) ? snapshot.aiProfileChangeKeys : []),
+        taskforceAgentWatermarks: new Map(Array.isArray(snapshot.taskforceAgentWatermarks) ? snapshot.taskforceAgentWatermarks : []),
+        taskforceAgentSkillWatermarks: new Map(Array.isArray(snapshot.taskforceAgentSkillWatermarks) ? snapshot.taskforceAgentSkillWatermarks : []),
+        agentConversationWatermarks: new Map(Array.isArray(snapshot.agentConversationWatermarks) ? snapshot.agentConversationWatermarks : []),
         documentWatermarks: new Map(Array.isArray(snapshot.documentWatermarks) ? snapshot.documentWatermarks : []),
         assetWatermarks: new Map(Array.isArray(snapshot.assetWatermarks) ? snapshot.assetWatermarks : []),
         documentReviewSessionWatermarks: new Map(Array.isArray(snapshot.documentReviewSessionWatermarks) ? snapshot.documentReviewSessionWatermarks : []),
         documentReviewCommentWatermarks: new Map(Array.isArray(snapshot.documentReviewCommentWatermarks) ? snapshot.documentReviewCommentWatermarks : []),
         annotatedAttachmentSessionWatermarks: new Map(Array.isArray(snapshot.annotatedAttachmentSessionWatermarks) ? snapshot.annotatedAttachmentSessionWatermarks : []),
         taskEventWatermarks: new Map(Array.isArray(snapshot.taskEventWatermarks) ? snapshot.taskEventWatermarks : []),
+        taxonomyChangeKey: typeof snapshot.taxonomyChangeKey === 'string' ? snapshot.taxonomyChangeKey : '',
     };
 }
 export function readPersistedSyncWatermarks(workspaceId, taxonomyStateFingerprint) {
@@ -263,7 +237,7 @@ export function readPersistedSyncWatermarks(workspaceId, taxonomyStateFingerprin
         if (!raw)
             return null;
         const parsed = JSON.parse(raw);
-        if (!parsed || (parsed.v !== 2 && parsed.v !== 3 && parsed.v !== 4 && parsed.v !== 5 && parsed.v !== 6 && parsed.v !== 7 && parsed.v !== 8 && parsed.v !== 9 && parsed.v !== 10 && parsed.v !== 11))
+        if (!parsed || (parsed.v !== 2 && parsed.v !== 3 && parsed.v !== 4 && parsed.v !== 5 && parsed.v !== 6 && parsed.v !== 7 && parsed.v !== 8 && parsed.v !== 9 && parsed.v !== 10 && parsed.v !== 11 && parsed.v !== 12))
             return null;
         return parsePersistedSyncWatermarksSnapshot(parsed, taxonomyStateFingerprint);
     }
@@ -277,7 +251,7 @@ export function savePersistedSyncWatermarks(workspaceId, data) {
     try {
         const key = `${WORKSPACE_SYNC_WATERMARKS_KEY_PREFIX}.${workspaceId}`;
         window.localStorage.setItem(key, JSON.stringify({
-            v: 11,
+            v: 12,
             savedAt: new Date().toISOString(),
             ...buildPersistedSyncWatermarksSnapshot(data)
         }));

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

@@ -1,31 +1 @@
-import type { WorkspaceSyncPhase } from '../../sync/workspaceSyncState';
-export interface WorkspacePullRequestPlan {
-    bootstrap: boolean;
-    cursor: string | null;
-    successEventType: 'bootstrap' | 'pull';
-}
-interface ResolveWorkspacePullRequestPlanArgs {
-    workspaceSyncPhase: WorkspaceSyncPhase;
-    forceCursorNull?: boolean;
-    currentCursor: string | null;
-}
-interface ResolveWorkspacePullSuccessPlanArgs {
-    workspaceSyncPhase: WorkspaceSyncPhase;
-    forceCursorNull?: boolean;
-    startupFullReconcileRan: boolean;
-    pendingSignature: string;
-    fallbackSignature: string;
-    lastPushedSignature: string;
-}
-export interface WorkspacePullSuccessPlan {
-    successEventType: 'bootstrap' | 'pull';
-    shouldCaptureAttachBootstrapBaseline: boolean;
-    shouldClearPendingSignature: boolean;
-    shouldRefreshReferenceSnapshots: boolean;
-    shouldSeedWorkspaceSnapshotPushBaseline: boolean;
-    shouldScheduleStartupFullReconcile: boolean;
-    deferredPushSignature: string | null;
-}
-export declare function resolveWorkspacePullRequestPlan({ workspaceSyncPhase, forceCursorNull, currentCursor }: ResolveWorkspacePullRequestPlanArgs): WorkspacePullRequestPlan;
-export declare function resolveWorkspacePullSuccessPlan({ workspaceSyncPhase, forceCursorNull, startupFullReconcileRan, pendingSignature, fallbackSignature, lastPushedSignature }: ResolveWorkspacePullSuccessPlanArgs): WorkspacePullSuccessPlan;
-export {};
+export * from '../../sync/engine/workspaceSyncEnginePullPolicy.js';

package/dist/hooks/sync/pullLifecycle.js

@@ -1,24 +1 @@
-export function resolveWorkspacePullRequestPlan({ workspaceSyncPhase, forceCursorNull, currentCursor }) {
-    const bootstrap = workspaceSyncPhase === 'attach-cloud';
-    return {
-        bootstrap,
-        cursor: bootstrap || forceCursorNull === true ? null : currentCursor,
-        successEventType: bootstrap ? 'bootstrap' : 'pull'
-    };
-}
-export function resolveWorkspacePullSuccessPlan({ workspaceSyncPhase, forceCursorNull, startupFullReconcileRan, pendingSignature, fallbackSignature, lastPushedSignature }) {
-    const bootstrap = workspaceSyncPhase === 'attach-cloud';
-    const nextSignature = pendingSignature || fallbackSignature;
-    const deferredPushSignature = (!bootstrap
-        && nextSignature
-        && nextSignature !== lastPushedSignature) ? nextSignature : null;
-    return {
-        successEventType: bootstrap ? 'bootstrap' : 'pull',
-        shouldCaptureAttachBootstrapBaseline: bootstrap,
-        shouldClearPendingSignature: bootstrap || deferredPushSignature !== null,
-        shouldRefreshReferenceSnapshots: bootstrap,
-        shouldSeedWorkspaceSnapshotPushBaseline: bootstrap,
-        shouldScheduleStartupFullReconcile: !forceCursorNull && !bootstrap && !startupFullReconcileRan,
-        deferredPushSignature
-    };
-}
+export * from '../../sync/engine/workspaceSyncEnginePullPolicy.js';

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

@@ -11,9 +11,12 @@ interface CreateRealtimeSyncBridgeArgs {
     realtimeSuppressedEventIdsRef: MutableRefObject<Set<string>>;
     clearWorkspaceRetry: () => void;
     isWorkspaceRetryPending: () => boolean;
+    isExecutionAuthorized?: () => boolean;
+    isServerOwned?: () => boolean;
+    signalServerWake?: (eventIds: string[]) => Promise<boolean>;
     pullWorkspaceChangesFromCloud: () => Promise<boolean>;
 }
-export declare function createRealtimeSyncBridge({ cloudAuthConfigured, runtimeMode, workspaceCloudSyncEnabled, workspaceSyncPhase, workspacePullInFlightRef, realtimePullDebounceRef, realtimeSuppressedEventIdsRef, clearWorkspaceRetry, isWorkspaceRetryPending, pullWorkspaceChangesFromCloud }: CreateRealtimeSyncBridgeArgs): {
+export declare function createRealtimeSyncBridge({ cloudAuthConfigured, runtimeMode, workspaceCloudSyncEnabled, workspaceSyncPhase, workspacePullInFlightRef, realtimePullDebounceRef, realtimeSuppressedEventIdsRef, clearWorkspaceRetry, isWorkspaceRetryPending, isExecutionAuthorized, isServerOwned, signalServerWake, pullWorkspaceChangesFromCloud }: CreateRealtimeSyncBridgeArgs): {
     handleRealtimeSignal: (signal: RealtimeSyncSignal) => void;
     recordSuppressedEventIds: (eventIds: Iterable<string>, options?: {
         queueRef?: MutableRefObject<string[]>;