@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/cloudSyncApi.js

@@ -1,3 +1,222 @@
+import { partitionWorkspaceSyncV2LegacyChanges } from './v3/workspaceSyncV2ProjectionExclusions.js';
+import { validateWorkspaceSyncEngineTransferCompletionGroup, } from './engine/workspaceSyncEngineTransferCompletion.js';
+import { WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR, resolveWorkspaceSyncV3CombinedCoverageForExclusions, resolveWorkspaceSyncV3CombinedWireContract } from './v3/workspaceSyncV3CombinedWireContract.js';
+const WORKSPACE_PULL_TIMEOUT_MS = 45_000;
+const WORKSPACE_REPAIR_PULL_TIMEOUT_MS = 180_000;
+function localBrowserApplyPermitContext(workspaceId, options) {
+    const completionGroup = options?.completionGroup;
+    if (!completionGroup)
+        return {};
+    validateWorkspaceSyncEngineTransferCompletionGroup(completionGroup);
+    if (completionGroup.workspaceId !== workspaceId) {
+        throw new TypeError('The local sync apply completion group workspace does not match the request.');
+    }
+    if (completionGroup.ownerMode !== 'browser-gateway') {
+        throw new TypeError('The local sync browser apply requires a browser-gateway completion group.');
+    }
+    return {
+        coordinatorGeneration: completionGroup.coordinatorGeneration,
+        permitIds: [...completionGroup.permitIds],
+    };
+}
+export async function getLocalWorkspaceContentPullObligations(workspaceId, limit = 100) {
+    const params = new URLSearchParams({
+        workspaceId,
+        limit: String(Math.max(1, Math.min(100, Math.floor(limit)))),
+    });
+    return requestJson(fetch(`/api/taskforce/sync/workspace/content-obligations?${params.toString()}`, {
+        credentials: 'include',
+        headers: { 'x-taskforce-workspace-id': workspaceId },
+    }));
+}
+export async function recordLocalWorkspaceContentPullObligationFailures(workspaceId, obligationIds, error) {
+    return requestJson(fetch('/api/taskforce/sync/workspace/content-obligations/failures', {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-taskforce-workspace-id': workspaceId,
+        },
+        body: JSON.stringify({ workspaceId, obligationIds, error }),
+    }));
+}
+async function resolveActiveLocalOwnership(workspaceId, candidateTaskIds, candidateInitiativeIds = [], candidateWorkstreamIds = [], readOwnership = getLocalTaskMetadataOwnership) {
+    const ownership = await readOwnership(workspaceId);
+    if (!ownership.ok) {
+        return ownership;
+    }
+    const candidates = new Set(Array.from(candidateTaskIds, (taskId) => String(taskId || '').trim()).filter(Boolean));
+    const initiativeCandidates = new Set(Array.from(candidateInitiativeIds, (id) => String(id || '').trim()).filter(Boolean));
+    const workstreamCandidates = new Set(Array.from(candidateWorkstreamIds, (id) => String(id || '').trim()).filter(Boolean));
+    const data = ownership.data;
+    if (data.success !== true
+        || data.contractVersion !== 3
+        || data.workspaceId !== workspaceId
+        || !Array.isArray(data.tasks)
+        || !Array.isArray(data.activeTaskRelationshipIds)
+        || !Array.isArray(data.initiatives)
+        || !Array.isArray(data.workstreams)
+        || !data.initiativeProjection || typeof data.initiativeProjection !== 'object'
+        || (data.initiativeProjection.owner !== 'v2' && data.initiativeProjection.owner !== 'v3')
+        || typeof data.initiativeProjection.epoch !== 'string'
+        || !/^\d+$/.test(data.initiativeProjection.epoch)
+        || data.activeTaskRelationshipIds.some((id) => typeof id !== 'string' || !id.trim())
+        || !data.taxonomy || typeof data.taxonomy !== 'object' || Array.isArray(data.taxonomy)
+        || typeof data.taxonomy.activeOperation !== 'boolean'
+        || typeof data.taxonomy.owned !== 'boolean'
+        || typeof data.taxonomy.entityRevision !== 'string' || !/^\d+$/.test(data.taxonomy.entityRevision)
+        || typeof data.taxonomy.lifecycleRevision !== 'string' || !/^\d+$/.test(data.taxonomy.lifecycleRevision)
+        || (data.taxonomy.lastSequence !== null
+            && (typeof data.taxonomy.lastSequence !== 'string' || !/^\d+$/.test(data.taxonomy.lastSequence)))) {
+        return {
+            ok: false,
+            status: 502,
+            data: { activeMetadataTaskIds: [], activeCreateTaskIds: [], activeDeleteTaskIds: [], activeLifecycleTaskIds: [], activeReopenTaskIds: [], activeTaskRelationshipIds: [], activeInitiativeIds: [], protectedInitiativeIds: [], protectedWorkstreamIds: [], taxonomyProtected: true, initiativeProjectionOwner: 'v3', initiativeProjectionEpoch: '0', combinedProjectionOwner: 'v2', combinedProjectionEpoch: '0' },
+        };
+    }
+    const combinedProjection = data.combinedProjection;
+    if (combinedProjection !== undefined && (!combinedProjection || typeof combinedProjection !== 'object' || Array.isArray(combinedProjection)
+        || (combinedProjection.owner !== 'v2' && combinedProjection.owner !== 'v3')
+        || typeof combinedProjection.epoch !== 'string'
+        || !/^\d+$/.test(combinedProjection.epoch))) {
+        return {
+            ok: false,
+            status: 502,
+            data: { activeMetadataTaskIds: [], activeCreateTaskIds: [], activeDeleteTaskIds: [], activeLifecycleTaskIds: [], activeReopenTaskIds: [], activeTaskRelationshipIds: [], activeInitiativeIds: [], protectedInitiativeIds: [], protectedWorkstreamIds: [], taxonomyProtected: true, initiativeProjectionOwner: 'v3', initiativeProjectionEpoch: '0', combinedProjectionOwner: 'v2', combinedProjectionEpoch: '0' },
+        };
+    }
+    const combinedWire = combinedProjection
+        ? resolveWorkspaceSyncV3CombinedWireContract({
+            coverageProfileId: combinedProjection.coverageProfileId,
+            coverageVersion: combinedProjection.coverageVersion,
+            coverageDigest: combinedProjection.coverageDigest,
+        })
+        : null;
+    if (combinedProjection?.owner === 'v3' && !combinedWire) {
+        return {
+            ok: false,
+            status: 502,
+            data: { activeMetadataTaskIds: [], activeCreateTaskIds: [], activeDeleteTaskIds: [], activeLifecycleTaskIds: [], activeReopenTaskIds: [], activeTaskRelationshipIds: [], activeInitiativeIds: [], protectedInitiativeIds: [], protectedWorkstreamIds: [], taxonomyProtected: true, initiativeProjectionOwner: 'v3', initiativeProjectionEpoch: '0', combinedProjectionOwner: 'v2', combinedProjectionEpoch: '0', combinedExcludedProjections: [] },
+        };
+    }
+    const normalizedEntries = [];
+    for (const entry of data.tasks) {
+        const taskId = String(entry?.taskId || '').trim();
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)
+            || !taskId
+            || typeof entry.activeOperation !== 'boolean'
+            || typeof entry.activeCreateOperation !== 'boolean'
+            || (entry.activeDeleteOperation !== undefined && typeof entry.activeDeleteOperation !== 'boolean')
+            || (entry.deleteOwned !== undefined && typeof entry.deleteOwned !== 'boolean')
+            || typeof entry.activeLifecycleOperation !== 'boolean'
+            || typeof entry.activeReopenOperation !== 'boolean'
+            || typeof entry.reopenAssigneeOwned !== 'boolean') {
+            return {
+                ok: false,
+                status: 502,
+                data: { activeMetadataTaskIds: [], activeCreateTaskIds: [], activeDeleteTaskIds: [], activeLifecycleTaskIds: [], activeReopenTaskIds: [], activeTaskRelationshipIds: [], activeInitiativeIds: [], protectedInitiativeIds: [], protectedWorkstreamIds: [], taxonomyProtected: true, initiativeProjectionOwner: 'v3', initiativeProjectionEpoch: '0', combinedProjectionOwner: 'v2', combinedProjectionEpoch: '0' },
+            };
+        }
+        normalizedEntries.push({ entry, taskId });
+    }
+    const eligibleEntries = normalizedEntries
+        .filter(({ taskId }) => taskId.length > 0 && candidates.has(taskId));
+    const activeMetadataTaskIds = Array.from(new Set(eligibleEntries
+        .filter(({ entry }) => entry?.activeOperation === true)
+        .map(({ taskId }) => taskId))).sort();
+    const activeCreateTaskIds = Array.from(new Set(eligibleEntries
+        .filter(({ entry }) => entry?.activeCreateOperation === true)
+        .map(({ taskId }) => taskId))).sort();
+    const activeDeleteTaskIds = Array.from(new Set(eligibleEntries
+        .filter(({ entry }) => entry?.activeDeleteOperation === true || entry?.deleteOwned === true)
+        .map(({ taskId }) => taskId))).sort();
+    const activeLifecycleTaskIds = Array.from(new Set(eligibleEntries
+        .filter(({ entry }) => entry?.activeLifecycleOperation === true)
+        .map(({ taskId }) => taskId))).sort();
+    const activeReopenTaskIds = Array.from(new Set(eligibleEntries
+        .filter(({ entry }) => entry?.activeReopenOperation === true)
+        .map(({ taskId }) => taskId))).sort();
+    const activeTaskRelationshipIds = Array.from(new Set(data.activeTaskRelationshipIds.map((id) => String(id).trim()))).sort();
+    const activeInitiativeIds = [];
+    const protectedInitiativeIds = [];
+    for (const entry of data.initiatives) {
+        const entityId = String(entry?.entityId || '').trim();
+        const valid = entry && typeof entry === 'object' && !Array.isArray(entry)
+            && entry.domain === 'initiative'
+            && entityId.length > 0
+            && typeof entry.activeOperation === 'boolean'
+            && typeof entry.owned === 'boolean'
+            && typeof entry.entityRevision === 'string' && /^\d+$/.test(entry.entityRevision)
+            && typeof entry.lifecycleRevision === 'string' && /^\d+$/.test(entry.lifecycleRevision)
+            && (entry.lastSequence === null || (typeof entry.lastSequence === 'string' && /^\d+$/.test(entry.lastSequence)))
+            && (entry.canonicalFingerprint === null || (typeof entry.canonicalFingerprint === 'string' && /^[a-f0-9]{64}$/.test(entry.canonicalFingerprint)));
+        if (!valid) {
+            return {
+                ok: false,
+                status: 502,
+                data: { activeMetadataTaskIds: [], activeCreateTaskIds: [], activeDeleteTaskIds: [], activeLifecycleTaskIds: [], activeReopenTaskIds: [], activeTaskRelationshipIds: [], activeInitiativeIds: [], protectedInitiativeIds: [], protectedWorkstreamIds: [], taxonomyProtected: true, initiativeProjectionOwner: 'v3', initiativeProjectionEpoch: '0', combinedProjectionOwner: 'v2', combinedProjectionEpoch: '0' },
+            };
+        }
+        if (!initiativeCandidates.has(entityId))
+            continue;
+        if (entry.activeOperation === true)
+            activeInitiativeIds.push(entityId);
+        if (entry.activeOperation === true || entry.owned === true)
+            protectedInitiativeIds.push(entityId);
+    }
+    const protectedWorkstreamIds = [];
+    for (const entry of data.workstreams) {
+        const entityId = String(entry?.entityId || '').trim();
+        const valid = entry && typeof entry === 'object' && !Array.isArray(entry)
+            && entry.domain === 'workstream'
+            && entityId.length > 0
+            && typeof entry.activeOperation === 'boolean'
+            && typeof entry.owned === 'boolean'
+            && typeof entry.entityRevision === 'string' && /^\d+$/.test(entry.entityRevision)
+            && typeof entry.lifecycleRevision === 'string' && /^\d+$/.test(entry.lifecycleRevision)
+            && (entry.lastSequence === null || (typeof entry.lastSequence === 'string' && /^\d+$/.test(entry.lastSequence)))
+            && (entry.canonicalFingerprint === null || (typeof entry.canonicalFingerprint === 'string' && /^[a-f0-9]{64}$/.test(entry.canonicalFingerprint)));
+        if (!valid) {
+            return {
+                ok: false,
+                status: 502,
+                data: { activeMetadataTaskIds: [], activeCreateTaskIds: [], activeDeleteTaskIds: [], activeLifecycleTaskIds: [], activeReopenTaskIds: [], activeTaskRelationshipIds: [], activeInitiativeIds: [], protectedInitiativeIds: [], protectedWorkstreamIds: [], taxonomyProtected: true, initiativeProjectionOwner: 'v3', initiativeProjectionEpoch: '0', combinedProjectionOwner: 'v2', combinedProjectionEpoch: '0' },
+            };
+        }
+        if (!workstreamCandidates.has(entityId))
+            continue;
+        if (entry.activeOperation === true || entry.owned === true)
+            protectedWorkstreamIds.push(entityId);
+    }
+    return {
+        ok: true,
+        status: ownership.status,
+        data: {
+            activeMetadataTaskIds,
+            activeCreateTaskIds,
+            activeDeleteTaskIds,
+            activeLifecycleTaskIds,
+            activeReopenTaskIds,
+            activeTaskRelationshipIds,
+            activeInitiativeIds: Array.from(new Set(activeInitiativeIds)).sort(),
+            protectedInitiativeIds: Array.from(new Set(protectedInitiativeIds)).sort(),
+            protectedWorkstreamIds: Array.from(new Set(protectedWorkstreamIds)).sort(),
+            taxonomyProtected: data.taxonomy.activeOperation === true || data.taxonomy.owned === true,
+            initiativeProjectionOwner: data.initiativeProjection.owner,
+            initiativeProjectionEpoch: data.initiativeProjection.epoch,
+            combinedProjectionOwner: combinedProjection?.owner === 'v3' ? 'v3' : 'v2',
+            combinedProjectionEpoch: combinedProjection && typeof combinedProjection.epoch === 'string'
+                ? combinedProjection.epoch
+                : '0',
+            combinedCoverage: combinedProjection?.owner === 'v3' && combinedWire
+                ? combinedWire.coverage
+                : undefined,
+            combinedExcludedProjections: combinedProjection?.owner === 'v3' && combinedWire
+                ? [...combinedWire.excludedProjections]
+                : [],
+        },
+    };
+}
 function toStatus(error) {
     const status = Number(error?.status);
     if (Number.isFinite(status) && status > 0)
@@ -42,9 +261,27 @@ async function requestJson(request) {
         return { ok: res.ok, status: res.status, data, retryAfterMs };
     }
     catch (error) {
-        return { ok: false, status: toStatus(error), data: {} };
+        const timedOut = String(error?.name || '').trim() === 'AbortError';
+        const fallbackData = timedOut
+            ? { error: 'Workspace sync pull request timed out.' }
+            : {};
+        return { ok: false, status: toStatus(error), data: fallbackData };
     }
 }
+function fetchWithTimeout(input, init, timeoutMs) {
+    const controller = typeof AbortController === 'function' ? new AbortController() : null;
+    const timer = controller
+        ? globalThis.setTimeout(() => controller.abort(), Math.max(1, Math.floor(timeoutMs)))
+        : null;
+    const request = fetch(input, {
+        ...init,
+        ...(controller ? { signal: controller.signal } : {})
+    });
+    return request.finally(() => {
+        if (timer !== null)
+            globalThis.clearTimeout(timer);
+    });
+}
 export async function pullUserSettings(resolveCloudAuthUrl) {
     return requestJson(fetch(resolveCloudAuthUrl('/api/taskforce/sync/user-settings'), {
         method: 'GET',
@@ -81,30 +318,381 @@ export async function pullWorkspaceChanges(resolveCloudAuthUrl, input) {
         params.set('cursor', input.cursor);
     if (input.repairMode === true)
         params.set('repair', '1');
+    if (input.contentMode === 'manifest')
+        params.set('content', 'manifest');
+    if (input.excludeInitiatives === true)
+        params.set('excludeInitiatives', '1');
+    if (input.excludedProjections?.length) {
+        params.set('excludeProjections', input.excludedProjections.join(','));
+        const coverage = resolveWorkspaceSyncV3CombinedCoverageForExclusions(input.excludedProjections);
+        if (coverage) {
+            params.set('coverageProfileId', coverage.coverageProfileId);
+            params.set('coverageVersion', String(coverage.coverageVersion));
+            params.set('coverageDigest', coverage.coverageDigest);
+        }
+    }
     const baseUrl = resolveCloudAuthUrl('/api/taskforce/sync/workspace/pull');
     const separator = baseUrl.includes('?') ? '&' : '?';
-    return requestJson(fetch(`${baseUrl}${separator}${params.toString()}`, {
+    return requestJson(fetchWithTimeout(`${baseUrl}${separator}${params.toString()}`, {
         method: 'GET',
         credentials: 'include'
-    }));
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function pullWorkspaceSyncV3Feed(resolveCloudAuthUrl, input) {
+    const params = new URLSearchParams({ workspaceId: input.workspaceId, limit: String(input.limit || 100) });
+    if (input.cursor)
+        params.set('cursor', input.cursor);
+    if (input.repairCursor)
+        params.set('repairCursor', input.repairCursor);
+    const baseUrl = resolveCloudAuthUrl('/api/taskforce/sync/v3/workspace/feed');
+    const separator = baseUrl.includes('?') ? '&' : '?';
+    return requestJson(fetchWithTimeout(`${baseUrl}${separator}${params.toString()}`, {
+        method: 'GET', credentials: 'include'
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function pullWorkspaceSyncV3CombinedFeed(resolveCloudAuthUrl, input) {
+    const coverage = input.coverage || WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR;
+    const params = new URLSearchParams({
+        workspaceId: input.workspaceId,
+        limit: String(input.limit || 100),
+        coverageProfileId: coverage.coverageProfileId,
+        coverageVersion: String(coverage.coverageVersion),
+        coverageDigest: coverage.coverageDigest,
+    });
+    if (input.cursor)
+        params.set('cursor', input.cursor);
+    if (input.repairCursor)
+        params.set('repairCursor', input.repairCursor);
+    if (input.forceRepair === true)
+        params.set('forceRepair', '1');
+    const baseUrl = resolveCloudAuthUrl('/api/taskforce/sync/v3/workspace/feed');
+    const separator = baseUrl.includes('?') ? '&' : '?';
+    const timeoutMs = input.forceRepair === true || Boolean(input.repairCursor)
+        ? WORKSPACE_REPAIR_PULL_TIMEOUT_MS
+        : WORKSPACE_PULL_TIMEOUT_MS;
+    return requestJson(fetchWithTimeout(`${baseUrl}${separator}${params.toString()}`, {
+        method: 'GET', credentials: 'include'
+    }, timeoutMs));
+}
+export async function getLocalWorkspaceSyncV3Projection(workspaceId) {
+    const params = new URLSearchParams({ workspaceId });
+    return requestJson(fetchWithTimeout(`/api/taskforce/sync/v3/local/feed?${params.toString()}`, {
+        method: 'GET', headers: { 'x-taskforce-workspace-id': workspaceId }, credentials: 'include'
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function applyLocalWorkspaceSyncV3Projection(workspaceId, input, options) {
+    return requestJson(fetchWithTimeout('/api/taskforce/sync/v3/local/feed', {
+        method: 'POST', headers: { 'Content-Type': 'application/json', 'x-taskforce-workspace-id': workspaceId },
+        credentials: 'include', body: JSON.stringify({
+            workspaceId,
+            ...input,
+            ...localBrowserApplyPermitContext(workspaceId, options),
+        })
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function getLocalWorkspaceSyncV3CombinedProjection(workspaceId, coverage = WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR) {
+    const params = new URLSearchParams({ workspaceId,
+        coverageProfileId: coverage.coverageProfileId,
+        coverageVersion: String(coverage.coverageVersion),
+        coverageDigest: coverage.coverageDigest });
+    return requestJson(fetchWithTimeout(`/api/taskforce/sync/v3/local/feed?${params.toString()}`, {
+        method: 'GET', headers: { 'x-taskforce-workspace-id': workspaceId }, credentials: 'include'
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function applyLocalWorkspaceSyncV3CombinedProjection(workspaceId, input, coverage = WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR, options) {
+    return requestJson(fetchWithTimeout('/api/taskforce/sync/v3/local/feed', {
+        method: 'POST', headers: { 'Content-Type': 'application/json', 'x-taskforce-workspace-id': workspaceId },
+        credentials: 'include', body: JSON.stringify({
+            workspaceId,
+            ...input,
+            ...coverage,
+            ...localBrowserApplyPermitContext(workspaceId, options),
+        })
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function getLocalWorkspaceSyncV3TaskCommentAudit(workspaceId) {
+    const params = new URLSearchParams({ workspaceId });
+    return requestJson(fetchWithTimeout(`/api/taskforce/sync/v3/local/task-comment-audit?${params.toString()}`, {
+        method: 'GET',
+        headers: { 'x-taskforce-workspace-id': workspaceId },
+        credentials: 'include',
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function pullWorkspaceSyncV3TaskCommentAudit(resolveCloudAuthUrl, input) {
+    const params = new URLSearchParams({
+        workspaceId: input.workspaceId,
+        limit: String(input.limit || 50),
+    });
+    if (input.cursor)
+        params.set('cursor', input.cursor);
+    const baseUrl = resolveCloudAuthUrl('/api/taskforce/sync/v3/workspace/task-comment-audit');
+    const separator = baseUrl.includes('?') ? '&' : '?';
+    return requestJson(fetchWithTimeout(`${baseUrl}${separator}${params.toString()}`, {
+        method: 'GET',
+        credentials: 'include',
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function applyLocalWorkspaceSyncV3TaskCommentAudit(workspaceId, page, options) {
+    return requestJson(fetchWithTimeout('/api/taskforce/sync/v3/local/task-comment-audit', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'x-taskforce-workspace-id': workspaceId },
+        credentials: 'include',
+        body: JSON.stringify({
+            workspaceId,
+            page,
+            ...localBrowserApplyPermitContext(workspaceId, options),
+        }),
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function completeLocalSyncAuthoritativeRepair(input) {
+    return requestJson(fetchWithTimeout('/api/taskforce/sync/v3/local/coordinator/recovery/authoritative-repair-complete', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-taskforce-workspace-id': input.workspaceId,
+        },
+        credentials: 'include',
+        body: JSON.stringify(input),
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function pullWorkspaceInitiativeRepair(resolveCloudAuthUrl, input) {
+    const params = new URLSearchParams({ workspaceId: input.workspaceId, limit: String(input.limit || 100) });
+    if (input.cursor)
+        params.set('cursor', input.cursor);
+    const baseUrl = resolveCloudAuthUrl('/api/taskforce/sync/workspace/initiative-repair');
+    const separator = baseUrl.includes('?') ? '&' : '?';
+    return requestJson(fetchWithTimeout(`${baseUrl}${separator}${params.toString()}`, {
+        method: 'GET', credentials: 'include'
+    }, WORKSPACE_REPAIR_PULL_TIMEOUT_MS));
+}
+export async function pullWorkspaceCombinedRepair(resolveCloudAuthUrl, input) {
+    const coverage = input.coverage || WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR;
+    const params = new URLSearchParams({ workspaceId: input.workspaceId, limit: String(input.limit || 100),
+        coverageProfileId: coverage.coverageProfileId,
+        coverageVersion: String(coverage.coverageVersion),
+        coverageDigest: coverage.coverageDigest });
+    if (input.cursor)
+        params.set('cursor', input.cursor);
+    const baseUrl = resolveCloudAuthUrl('/api/taskforce/sync/workspace/combined-repair');
+    const separator = baseUrl.includes('?') ? '&' : '?';
+    return requestJson(fetchWithTimeout(`${baseUrl}${separator}${params.toString()}`, {
+        method: 'GET', credentials: 'include'
+    }, WORKSPACE_REPAIR_PULL_TIMEOUT_MS));
+}
+export async function getLocalWorkspaceContentManifest(workspaceId) {
+    const params = new URLSearchParams({ workspaceId });
+    return requestJson(fetchWithTimeout(`/api/taskforce/sync/workspace/content-manifest?${params.toString()}`, {
+        method: 'GET',
+        headers: { 'x-taskforce-workspace-id': workspaceId },
+        credentials: 'include'
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function pullWorkspaceContent(resolveCloudAuthUrl, input) {
+    return requestJson(fetchWithTimeout(resolveCloudAuthUrl('/api/taskforce/sync/workspace/content'), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify(input)
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
+export async function prepareWorkspacePushChanges(input, dependencies = {}) {
+    const taskUpsertIds = input.changes
+        .filter((change) => change.op === 'upsert')
+        .map((change) => String(change.task?.id || '').trim())
+        .filter(Boolean);
+    const taskDeleteIds = input.changes
+        .filter((change) => change.op === 'delete')
+        .map((change) => String(change.taskId || '').trim())
+        .filter(Boolean);
+    const taskUpsertIdSet = new Set(taskUpsertIds);
+    const initiativeIds = input.changes
+        .filter((change) => change.op === 'initiative-upsert')
+        .map((change) => String(change.initiative?.id || '').trim())
+        .filter(Boolean);
+    const workstreamIds = input.changes
+        .filter((change) => change.op === 'workstream-upsert')
+        .map((change) => String(change.workstream?.id || '').trim())
+        .filter(Boolean);
+    let activeV3TaskMetadataIds = [];
+    let activeV3TaskLifecycleIds = [];
+    let activeV3TaskReopenAssigneeIds = [];
+    let activeV3TaskCreateIds = new Set();
+    let activeV3TaskDeleteIds = new Set();
+    let activeTaskRelationshipIds = new Set();
+    let taxonomyProtected = false;
+    let activeV3InitiativeIds = [];
+    let protectedInitiativeIds = new Set();
+    let protectedWorkstreamIds = new Set();
+    let initiativeProjectionOwner = 'v2';
+    let combinedProjectionOwner = 'v2';
+    let combinedProjectionEpoch = '0';
+    let combinedCoverage = null;
+    let combinedExcludedProjections = [];
+    if (input.changes.length > 0) {
+        const ownership = await resolveActiveLocalOwnership(input.workspaceId, [...taskUpsertIds, ...taskDeleteIds], initiativeIds, workstreamIds, dependencies.readOwnership);
+        if (!ownership.ok) {
+            return {
+                ok: false,
+                status: ownership.status,
+                data: ownership.data,
+                retryAfterMs: ownership.retryAfterMs,
+            };
+        }
+        activeV3TaskCreateIds = new Set(ownership.data.activeCreateTaskIds);
+        activeV3TaskDeleteIds = new Set(ownership.data.activeDeleteTaskIds);
+        activeTaskRelationshipIds = new Set(ownership.data.activeTaskRelationshipIds);
+        taxonomyProtected = ownership.data.taxonomyProtected;
+        activeV3InitiativeIds = ownership.data.activeInitiativeIds;
+        protectedInitiativeIds = new Set(ownership.data.protectedInitiativeIds);
+        protectedWorkstreamIds = new Set(ownership.data.protectedWorkstreamIds);
+        initiativeProjectionOwner = ownership.data.initiativeProjectionOwner;
+        combinedProjectionOwner = ownership.data.combinedProjectionOwner;
+        combinedProjectionEpoch = ownership.data.combinedProjectionEpoch;
+        combinedCoverage = ownership.data.combinedCoverage || null;
+        combinedExcludedProjections = ownership.data.combinedExcludedProjections || [];
+        activeV3TaskMetadataIds = ownership.data.activeMetadataTaskIds
+            .filter((taskId) => taskUpsertIdSet.has(taskId) && !activeV3TaskCreateIds.has(taskId));
+        activeV3TaskLifecycleIds = ownership.data.activeLifecycleTaskIds
+            .filter((taskId) => taskUpsertIdSet.has(taskId) && !activeV3TaskCreateIds.has(taskId));
+        activeV3TaskReopenAssigneeIds = ownership.data.activeReopenTaskIds
+            .filter((taskId) => taskUpsertIdSet.has(taskId) && !activeV3TaskCreateIds.has(taskId));
+    }
+    const ownershipFilteredChanges = input.changes.filter((change) => {
+        if (change.op === 'upsert')
+            return !activeV3TaskCreateIds.has(String(change.task?.id || '').trim());
+        if (change.op === 'delete') {
+            return !activeV3TaskDeleteIds.has(String(change.taskId || '').trim());
+        }
+        if (change.op === 'task-relationship-upsert' || change.op === 'task-relationship-delete') {
+            return !activeTaskRelationshipIds.has(String(change.relationship?.id || '').trim());
+        }
+        if (change.op === 'taxonomy-upsert')
+            return !taxonomyProtected;
+        if (change.op === 'initiative-upsert') {
+            return initiativeProjectionOwner !== 'v3'
+                && !protectedInitiativeIds.has(String(change.initiative?.id || '').trim());
+        }
+        if (change.op === 'workstream-upsert') {
+            return !protectedWorkstreamIds.has(String(change.workstream?.id || '').trim());
+        }
+        return true;
+    });
+    const changes = partitionWorkspaceSyncV2LegacyChanges(ownershipFilteredChanges, new Set(combinedExcludedProjections)).changes;
+    const combinedV3SuppressedChangeCount = combinedProjectionOwner === 'v3'
+        ? input.changes.length - changes.length
+        : 0;
+    return {
+        ok: true,
+        status: 200,
+        data: {
+            changes,
+            ownership: {
+                activeV3TaskMetadataIds,
+                activeV3TaskLifecycleIds,
+                activeV3TaskReopenAssigneeIds,
+                activeV3InitiativeIds,
+                initiativeProjectionOwner,
+                combinedProjectionOwner,
+                combinedProjectionEpoch,
+                combinedCoverage,
+                combinedExcludedProjections,
+                combinedV3SuppressedChangeCount,
+            },
+        },
+    };
 }
 export async function pushWorkspaceChanges(resolveCloudAuthUrl, input) {
+    const prepared = await prepareWorkspacePushChanges({ workspaceId: input.workspaceId, changes: input.changes });
+    if (!prepared.ok)
+        return prepared;
+    const { changes, ownership } = prepared.data;
+    if (changes.length === 0) {
+        return { ok: true, status: 204, data: { success: true, skipped: true } };
+    }
     return requestJson(fetch(resolveCloudAuthUrl('/api/taskforce/sync/workspace/push'), {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         credentials: 'include',
         body: JSON.stringify({
             ...input,
+            changes,
+            ...(ownership.activeV3TaskMetadataIds.length > 0 ? { activeV3TaskMetadataIds: ownership.activeV3TaskMetadataIds } : {}),
+            ...(ownership.activeV3TaskLifecycleIds.length > 0 ? { activeV3TaskLifecycleIds: ownership.activeV3TaskLifecycleIds } : {}),
+            ...(ownership.activeV3TaskReopenAssigneeIds.length > 0 ? { activeV3TaskReopenAssigneeIds: ownership.activeV3TaskReopenAssigneeIds } : {}),
+            ...(ownership.activeV3InitiativeIds.length > 0 ? { activeV3InitiativeIds: ownership.activeV3InitiativeIds } : {}),
+            ...(ownership.initiativeProjectionOwner === 'v3' ? { v3InitiativeProjectionOwned: true } : {}),
+            ...(ownership.combinedCoverage ? {
+                combinedCoverage: ownership.combinedCoverage,
+                excludedProjections: ownership.combinedExcludedProjections || [],
+            } : {}),
             ...(input.repairMode === true ? { repair: true } : {})
         })
     }));
 }
+export async function getLocalTaskMetadataOwnership(workspaceId) {
+    const params = new URLSearchParams({ workspaceId });
+    return requestJson(fetchWithTimeout(`/api/taskforce/sync/v3/local/metadata-ownership?${params.toString()}`, {
+        method: 'GET',
+        headers: { 'x-taskforce-workspace-id': workspaceId },
+        credentials: 'include',
+    }, WORKSPACE_PULL_TIMEOUT_MS));
+}
 export async function bootstrapPushWorkspaceSnapshot(resolveCloudAuthUrl, input) {
+    const taskIds = [...input.tasks, ...input.archived]
+        .map((task) => String(task?.id || '').trim())
+        .filter(Boolean);
+    let activeV3TaskMetadataIds = [];
+    let activeV3TaskLifecycleIds = [];
+    let activeV3TaskReopenAssigneeIds = [];
+    let activeV3TaskCreateIds = new Set();
+    let taxonomyProtected = false;
+    let activeV3InitiativeIds = [];
+    let protectedInitiativeIds = new Set();
+    let protectedWorkstreamIds = new Set();
+    let initiativeProjectionOwner = 'v2';
+    const initiativeIds = (input.initiatives || []).map((initiative) => String(initiative?.id || '').trim()).filter(Boolean);
+    const workstreamIds = (input.workstreams || []).map((workstream) => String(workstream?.id || '').trim()).filter(Boolean);
+    const hasTaxonomySnapshot = Array.isArray(input.taxonomies);
+    if (taskIds.length > 0 || hasTaxonomySnapshot || initiativeIds.length > 0 || workstreamIds.length > 0) {
+        const ownership = await resolveActiveLocalOwnership(input.workspaceId, taskIds, initiativeIds, workstreamIds);
+        if (!ownership.ok)
+            return ownership;
+        activeV3TaskCreateIds = new Set(ownership.data.activeCreateTaskIds);
+        activeV3TaskMetadataIds = ownership.data.activeMetadataTaskIds
+            .filter((taskId) => !activeV3TaskCreateIds.has(taskId));
+        activeV3TaskLifecycleIds = ownership.data.activeLifecycleTaskIds
+            .filter((taskId) => !activeV3TaskCreateIds.has(taskId));
+        activeV3TaskReopenAssigneeIds = ownership.data.activeReopenTaskIds
+            .filter((taskId) => !activeV3TaskCreateIds.has(taskId));
+        taxonomyProtected = ownership.data.taxonomyProtected;
+        activeV3InitiativeIds = ownership.data.activeInitiativeIds;
+        protectedInitiativeIds = new Set(ownership.data.protectedInitiativeIds);
+        protectedWorkstreamIds = new Set(ownership.data.protectedWorkstreamIds);
+        initiativeProjectionOwner = ownership.data.initiativeProjectionOwner;
+    }
+    const tasks = input.tasks.filter((task) => !activeV3TaskCreateIds.has(String(task?.id || '').trim()));
+    const archived = input.archived.filter((task) => !activeV3TaskCreateIds.has(String(task?.id || '').trim()));
+    const initiatives = initiativeProjectionOwner === 'v3'
+        ? []
+        : (input.initiatives || []).filter((initiative) => (!protectedInitiativeIds.has(String(initiative?.id || '').trim())));
+    const workstreams = (input.workstreams || []).filter((workstream) => (!protectedWorkstreamIds.has(String(workstream?.id || '').trim())));
     return requestJson(fetch(resolveCloudAuthUrl('/api/taskforce/sync/workspace/bootstrap-push'), {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         credentials: 'include',
-        body: JSON.stringify(input)
+        body: JSON.stringify({
+            ...input,
+            ...(taxonomyProtected ? { taxonomies: undefined } : {}),
+            tasks,
+            archived,
+            ...(input.initiatives ? { initiatives } : {}),
+            ...(input.workstreams ? { workstreams } : {}),
+            ...(activeV3TaskMetadataIds.length > 0 ? { activeV3TaskMetadataIds } : {}),
+            ...(activeV3TaskLifecycleIds.length > 0 ? { activeV3TaskLifecycleIds } : {}),
+            ...(activeV3TaskReopenAssigneeIds.length > 0 ? { activeV3TaskReopenAssigneeIds } : {}),
+            ...(activeV3InitiativeIds.length > 0 ? { activeV3InitiativeIds } : {}),
+            ...(initiativeProjectionOwner === 'v3' ? { v3InitiativeProjectionOwned: true } : {}),
+        })
     }));
 }
 export async function applyLocalWorkspaceChanges(workspaceId, changes, options) {
@@ -113,6 +701,10 @@ export async function applyLocalWorkspaceChanges(workspaceId, changes, options)
         changes,
         workspaceMembers: Array.isArray(options?.workspaceMembers) ? options.workspaceMembers : undefined,
         ...(options?.repairMode === true ? { repair: true } : {}),
+        excludedProjections: options?.excludedProjections,
+        contentPullObligations: options?.contentPullObligations,
+        contentPullResolutionClaims: options?.contentPullResolutionClaims,
+        ...localBrowserApplyPermitContext(workspaceId, options),
         bootstrapSnapshot: options?.bootstrapSnapshot
             ? {
                 currentAnnotatedAttachmentSessionIds: Array.isArray(options.bootstrapSnapshot.currentAnnotatedAttachmentSessionIds)

package/dist/sync/collaborationSyncPayload.d.ts

@@ -1,4 +1,4 @@
-import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot } from './workspaceSyncModel.js';
+import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAgentRoleSnapshot, WorkspaceSyncAgentConversationSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncTaskforceAgentSnapshot, WorkspaceSyncTaskforceAgentSkillSnapshot } from './workspaceSyncModel.js';
 import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
 import type { AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 export declare function normalizeAiProfileSyncPayload(raw: unknown, workspaceId: string, normalizeSurfaceType: (value: unknown, context: {
@@ -16,6 +16,10 @@ export declare function normalizeDocumentReviewCommentSyncPayload(raw: unknown,
     sourceWatermark?: string;
 }): WorkspaceSyncDocumentReviewCommentSnapshot | null;
 export declare function normalizeAnnotatedAttachmentSessionSyncPayload(raw: unknown, expectedWorkspaceId?: string, sourceWatermark?: string): WorkspaceSyncAnnotatedAttachmentSessionSnapshot | null;
+export declare function normalizeTaskforceAgentSyncPayload(raw: unknown, expectedWorkspaceId?: string, sourceWatermark?: string): WorkspaceSyncTaskforceAgentSnapshot | null;
+export declare function normalizeAgentRoleSyncPayload(raw: unknown, expectedWorkspaceId?: string, sourceWatermark?: string): WorkspaceSyncAgentRoleSnapshot | null;
+export declare function normalizeTaskforceAgentSkillSyncPayload(raw: unknown, expectedWorkspaceId?: string, sourceWatermark?: string): WorkspaceSyncTaskforceAgentSkillSnapshot | null;
+export declare function normalizeAgentConversationSyncPayload(raw: unknown, expectedWorkspaceId?: string, sourceWatermark?: string): WorkspaceSyncAgentConversationSnapshot | null;
 export declare function normalizeDeleteSyncPayload(raw: unknown, idKey: 'sessionId' | 'commentId'): {
     id: string;
     deletedAt: string;