@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/sync/v3/workspaceSyncV3CombinedRepairMaterialization.d.ts

@@ -4,6 +4,7 @@ import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE } from './workspaceSyncV3Nest
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE } from './workspaceSyncV3WorkflowCoverage.js';
 import { WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE } from './workspaceSyncV3PlanningOrderCoverage.js';
 import { WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE } from './workspaceSyncV3TaskCoverCoverage.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE } from './workspaceSyncV3WorkflowTaskCoverCoverage.js';
 import { type WorkspaceSyncV3FeedEntry } from './workspaceSyncV3Feed.js';
 import { type WorkspaceSyncV3FeedCursorKeyring } from './workspaceSyncV3FeedCursorKeys.js';
 export interface WorkspaceSyncV3CombinedRepairCursor {
@@ -22,7 +23,7 @@ export interface WorkspaceSyncV3CombinedRepairPage {
     success: true;
     protocolVersion: 3;
     workspaceId: string;
-    coverage: typeof WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE;
+    coverage: typeof WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE | typeof WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE;
     snapshotId: string;
     snapshotSequence: string;
     expiresAt: string;
@@ -49,6 +50,7 @@ export declare function decodeWorkspaceSyncV3NestedRepairCursor(raw: string | nu
 export declare function decodeWorkspaceSyncV3WorkflowRepairCursor(raw: string | null | undefined, keyring: WorkspaceSyncV3FeedCursorKeyring): WorkspaceSyncV3CombinedRepairCursor | null;
 export declare function decodeWorkspaceSyncV3PlanningOrderRepairCursor(raw: string | null | undefined, keyring: WorkspaceSyncV3FeedCursorKeyring): WorkspaceSyncV3CombinedRepairCursor | null;
 export declare function decodeWorkspaceSyncV3TaskCoverRepairCursor(raw: string | null | undefined, keyring: WorkspaceSyncV3FeedCursorKeyring): WorkspaceSyncV3CombinedRepairCursor | null;
+export declare function decodeWorkspaceSyncV3WorkflowTaskCoverRepairCursor(raw: string | null | undefined, keyring: WorkspaceSyncV3FeedCursorKeyring): WorkspaceSyncV3CombinedRepairCursor | null;
 export declare const WORKSPACE_SYNC_REPAIR_SNAPSHOT_CLEANUP_BATCH_SIZE = 500;
 export declare function buildWorkspaceSyncV3CombinedRepairPage(input: {
     core: TaskforceCore;
@@ -61,11 +63,13 @@ export declare function buildWorkspaceSyncV3CombinedRepairPage(input: {
     now?: string;
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
+    workflowTaskCoverCoverage?: boolean;
     planningOrderCoverage?: boolean;
     taskCoverCoverage?: boolean;
     coveredLegacyWritesFenced?: boolean;
 }): WorkspaceSyncV3CombinedRepairPage;
-export declare function buildWorkspaceSyncV3NestedRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
-export declare function buildWorkspaceSyncV3WorkflowRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
-export declare function buildWorkspaceSyncV3PlanningOrderRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
-export declare function buildWorkspaceSyncV3TaskCoverRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3NestedRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'workflowTaskCoverCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3WorkflowRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'workflowTaskCoverCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3PlanningOrderRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'workflowTaskCoverCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3TaskCoverRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'workflowTaskCoverCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;
+export declare function buildWorkspaceSyncV3WorkflowTaskCoverRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'workflowTaskCoverCoverage' | 'planningOrderCoverage' | 'taskCoverCoverage'>): WorkspaceSyncV3CombinedRepairPage;

package/dist/sync/v3/workspaceSyncV3CombinedRepairMaterialization.js

@@ -1,12 +1,13 @@
 import { createHmac, randomUUID, timingSafeEqual } from 'crypto';
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 import { decodeCanonicalWorkspaceSyncBase64Url } from './workspaceSyncV3CursorEncoding.js';
-import { prepareWorkspaceSyncV3CombinedRepairSnapshot, prepareWorkspaceSyncV3NestedRepairSnapshot, prepareWorkspaceSyncV3PlanningOrderRepairSnapshot, prepareWorkspaceSyncV3TaskCoverRepairSnapshot, prepareWorkspaceSyncV3WorkflowRepairSnapshot, } from './workspaceSyncV3CombinedRepairBaseline.js';
+import { prepareWorkspaceSyncV3CombinedRepairSnapshot, prepareWorkspaceSyncV3NestedRepairSnapshot, prepareWorkspaceSyncV3PlanningOrderRepairSnapshot, prepareWorkspaceSyncV3TaskCoverRepairSnapshot, prepareWorkspaceSyncV3WorkflowRepairSnapshot, prepareWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot, } from './workspaceSyncV3CombinedRepairBaseline.js';
 import { validateWorkspaceSyncV3CombinedFeedEntry, WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE, } from './workspaceSyncV3CombinedCoverage.js';
 import { validateWorkspaceSyncV3NestedCoverageFeedEntry, WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE, } from './workspaceSyncV3NestedCoverage.js';
 import { validateWorkspaceSyncV3WorkflowCoverageFeedEntry, WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE, } from './workspaceSyncV3WorkflowCoverage.js';
 import { validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry, WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE, } from './workspaceSyncV3PlanningOrderCoverage.js';
 import { validateWorkspaceSyncV3TaskCoverCoverageFeedEntry, WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE, } from './workspaceSyncV3TaskCoverCoverage.js';
+import { validateWorkspaceSyncV3WorkflowTaskCoverCoverageFeedEntry, WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE, } from './workspaceSyncV3WorkflowTaskCoverCoverage.js';
 import { createWorkspaceSyncV3FeedResumeCursor, WorkspaceSyncV3FeedOperationTooLargeError, } from './workspaceSyncV3Feed.js';
 import { findWorkspaceSyncV3FeedCursorVerificationKey, } from './workspaceSyncV3FeedCursorKeys.js';
 import { WORKSPACE_SYNC_COMBINED_PROJECTION, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
@@ -99,16 +100,21 @@ export function decodeWorkspaceSyncV3PlanningOrderRepairCursor(raw, keyring) {
 export function decodeWorkspaceSyncV3TaskCoverRepairCursor(raw, keyring) {
     return decodeRepairCursor(raw, keyring, WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE);
 }
+export function decodeWorkspaceSyncV3WorkflowTaskCoverRepairCursor(raw, keyring) {
+    return decodeRepairCursor(raw, keyring, WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE);
+}
 function repairProfile(coverage) {
-    return coverage === 'workflow'
-        ? WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE
-        : coverage === 'task-cover'
-            ? WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE
-            : coverage === 'planning-order'
-                ? WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE
-                : coverage === 'nested'
-                    ? WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE
-                    : WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE;
+    return coverage === 'workflow-task-cover'
+        ? WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE
+        : coverage === 'workflow'
+            ? WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE
+            : coverage === 'task-cover'
+                ? WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE
+                : coverage === 'planning-order'
+                    ? WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE
+                    : coverage === 'nested'
+                        ? WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE
+                        : WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE;
 }
 function containsCurrentEntityEventInventory(input) {
     if (input.coverage === 'combined')
@@ -355,15 +361,17 @@ function mapEntry(row, coverage) {
         payloadFingerprint: String(row.payload_fingerprint || ''), payload,
         occurredAt: timestamp(row.occurred_at, 'Combined repair occurrence time'),
     };
-    (coverage === 'workflow'
-        ? validateWorkspaceSyncV3WorkflowCoverageFeedEntry
-        : coverage === 'task-cover'
-            ? validateWorkspaceSyncV3TaskCoverCoverageFeedEntry
-            : coverage === 'planning-order'
-                ? validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry
-                : coverage === 'nested'
-                    ? validateWorkspaceSyncV3NestedCoverageFeedEntry
-                    : validateWorkspaceSyncV3CombinedFeedEntry)(entry);
+    (coverage === 'workflow-task-cover'
+        ? validateWorkspaceSyncV3WorkflowTaskCoverCoverageFeedEntry
+        : coverage === 'workflow'
+            ? validateWorkspaceSyncV3WorkflowCoverageFeedEntry
+            : coverage === 'task-cover'
+                ? validateWorkspaceSyncV3TaskCoverCoverageFeedEntry
+                : coverage === 'planning-order'
+                    ? validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry
+                    : coverage === 'nested'
+                        ? validateWorkspaceSyncV3NestedCoverageFeedEntry
+                        : validateWorkspaceSyncV3CombinedFeedEntry)(entry);
     return entry;
 }
 function finalizePage(input) {
@@ -420,15 +428,17 @@ export function buildWorkspaceSyncV3CombinedRepairPage(input) {
     const pageSize = Math.max(1, Math.min(MAX_PAGE_SIZE, Math.floor(input.pageSize || DEFAULT_PAGE_SIZE)));
     const maxResponseBytes = Math.max(1024, Math.min(8 * 1024 * 1024, Math.floor(input.maxResponseBytes || DEFAULT_MAX_RESPONSE_BYTES)));
     const db = input.core.getDatabaseAdapter();
-    const coverage = input.workflowCoverage
-        ? 'workflow'
-        : input.taskCoverCoverage
-            ? 'task-cover'
-            : input.planningOrderCoverage
-                ? 'planning-order'
-                : input.nestedCoverage
-                    ? 'nested'
-                    : 'combined';
+    const coverage = input.workflowTaskCoverCoverage
+        ? 'workflow-task-cover'
+        : input.workflowCoverage
+            ? 'workflow'
+            : input.taskCoverCoverage
+                ? 'task-cover'
+                : input.planningOrderCoverage
+                    ? 'planning-order'
+                    : input.nestedCoverage
+                        ? 'nested'
+                        : 'combined';
     if (input.cursor && Date.parse(input.cursor.expiresAt) <= Date.parse(now)) {
         cleanupExpiredBestEffort(input.core, tenantId, workspaceId, now);
         throw new WorkspaceSyncV3CombinedRepairSnapshotUnavailableError();
@@ -467,20 +477,23 @@ export function buildWorkspaceSyncV3CombinedRepairPage(input) {
                 return { metadata: reusable, reused: true,
                     insertedBaselineEntities: 0, insertedBaselineJournalRows: 0 };
             const repairStartedAt = Date.now();
-            const prepared = coverage === 'workflow'
-                ? prepareWorkspaceSyncV3WorkflowRepairSnapshot({ core: input.core, workspaceId, now,
+            const prepared = coverage === 'workflow-task-cover'
+                ? prepareWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot({ core: input.core, workspaceId, now,
                     coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
-                : coverage === 'planning-order'
-                    ? prepareWorkspaceSyncV3PlanningOrderRepairSnapshot({ core: input.core, workspaceId, now,
+                : coverage === 'workflow'
+                    ? prepareWorkspaceSyncV3WorkflowRepairSnapshot({ core: input.core, workspaceId, now,
                         coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
-                    : coverage === 'task-cover'
-                        ? prepareWorkspaceSyncV3TaskCoverRepairSnapshot({ core: input.core, workspaceId, now,
+                    : coverage === 'planning-order'
+                        ? prepareWorkspaceSyncV3PlanningOrderRepairSnapshot({ core: input.core, workspaceId, now,
                             coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
-                        : coverage === 'nested'
-                            ? prepareWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId, now,
+                        : coverage === 'task-cover'
+                            ? prepareWorkspaceSyncV3TaskCoverRepairSnapshot({ core: input.core, workspaceId, now,
                                 coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
-                            : prepareWorkspaceSyncV3CombinedRepairSnapshot({ core: input.core, workspaceId, now,
-                                coveredLegacyWritesFenced: input.coveredLegacyWritesFenced });
+                            : coverage === 'nested'
+                                ? prepareWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId, now,
+                                    coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
+                                : prepareWorkspaceSyncV3CombinedRepairSnapshot({ core: input.core, workspaceId, now,
+                                    coveredLegacyWritesFenced: input.coveredLegacyWritesFenced });
             // Production expiry is sampled at the end of persistence, after
             // every immutable payload row has committed in the same lock.
             const materializationStartedAt = input.now
@@ -576,3 +589,6 @@ export function buildWorkspaceSyncV3PlanningOrderRepairPage(input) {
 export function buildWorkspaceSyncV3TaskCoverRepairPage(input) {
     return buildWorkspaceSyncV3CombinedRepairPage({ ...input, taskCoverCoverage: true });
 }
+export function buildWorkspaceSyncV3WorkflowTaskCoverRepairPage(input) {
+    return buildWorkspaceSyncV3CombinedRepairPage({ ...input, workflowTaskCoverCoverage: true });
+}

package/dist/sync/v3/workspaceSyncV3CombinedRepairSnapshot.d.ts

@@ -35,6 +35,8 @@ export declare function listWorkspaceSyncV3NestedRepairCandidates(core: Taskforc
 export declare function listWorkspaceSyncV3TaskCoverRepairCandidates(core: TaskforceCore, workspaceId: string): WorkspaceSyncV3CombinedRepairCandidate[];
 /** Candidate v5 inventory. Coverage-v3/v4 inventories intentionally remain unchanged. */
 export declare function listWorkspaceSyncV3WorkflowRepairCandidates(core: TaskforceCore, workspaceId: string): WorkspaceSyncV3CombinedRepairCandidate[];
+/** Candidate v8 inventory. It composes v7 task-cover state with workflow runtime. */
+export declare function listWorkspaceSyncV3WorkflowTaskCoverRepairCandidates(core: TaskforceCore, workspaceId: string): WorkspaceSyncV3CombinedRepairCandidate[];
 /** Candidate v6 inventory. Workflow v5 remains an independent dark contract. */
 export declare function listWorkspaceSyncV3PlanningOrderRepairCandidates(core: TaskforceCore, workspaceId: string): WorkspaceSyncV3CombinedRepairCandidate[];
 export declare function buildWorkspaceSyncV3CombinedRepairSnapshot(input: {
@@ -51,6 +53,7 @@ export declare function buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCand
     inventory: WorkspaceSyncV3CombinedRepairCandidate[];
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
+    workflowTaskCoverCoverage?: boolean;
     planningOrderCoverage?: boolean;
     taskCoverCoverage?: boolean;
 }): {
@@ -85,4 +88,11 @@ export declare function buildWorkspaceSyncV3TaskCoverRepairSnapshot(input: {
     snapshotSequence: string;
     entries: WorkspaceSyncV3FeedEntry[];
 };
+export declare function buildWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+}): {
+    snapshotSequence: string;
+    entries: WorkspaceSyncV3FeedEntry[];
+};
 export {};

package/dist/sync/v3/workspaceSyncV3CombinedRepairSnapshot.js

@@ -15,6 +15,7 @@ import { projectWorkspaceSyncV3WorkflowRuntimeJournalRow, } from './workspaceSyn
 import { validateWorkspaceSyncV3WorkflowCoverageFeedEntry, WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE, } from './workspaceSyncV3WorkflowCoverage.js';
 import { validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry, WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE, } from './workspaceSyncV3PlanningOrderCoverage.js';
 import { validateWorkspaceSyncV3TaskCoverCoverageFeedEntry, WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE, } from './workspaceSyncV3TaskCoverCoverage.js';
+import { validateWorkspaceSyncV3WorkflowTaskCoverCoverageFeedEntry, WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE, } from './workspaceSyncV3WorkflowTaskCoverCoverage.js';
 import { projectWorkspaceSyncV3WorkstreamTaskOrderJournalRow } from './workspaceSyncV3WorkstreamTaskOrderProjection.js';
 import { serializeWorkstreamTaskOrderForSync } from './workstreamTaskOrderSync.js';
 import { serializeTaxonomyStateForSync } from './taxonomySyncPayload.js';
@@ -31,6 +32,8 @@ const PLANNING_ORDER_PROJECTION_RANK = new Map(WORKSPACE_SYNC_V3_PLANNING_ORDER_
     .map((projection, index) => [projection.projectionId, index]));
 const TASK_COVER_PROJECTION_RANK = new Map(WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE.projections
     .map((projection, index) => [projection.projectionId, index]));
+const WORKFLOW_TASK_COVER_PROJECTION_RANK = new Map(WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE.projections
+    .map((projection, index) => [projection.projectionId, index]));
 export class WorkspaceSyncV3CombinedRepairBaselineRequiredError extends Error {
     missing;
     code = 'WORKSPACE_SYNC_V3_COMBINED_REPAIR_BASELINE_REQUIRED';
@@ -43,15 +46,17 @@ function compareCodeUnits(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
 function projectionRank(entry, coverage) {
-    const ranks = coverage === 'workflow'
-        ? WORKFLOW_PROJECTION_RANK
-        : coverage === 'task-cover'
-            ? TASK_COVER_PROJECTION_RANK
-            : coverage === 'planning-order'
-                ? PLANNING_ORDER_PROJECTION_RANK
-                : coverage === 'nested'
-                    ? NESTED_PROJECTION_RANK
-                    : COMBINED_PROJECTION_RANK;
+    const ranks = coverage === 'workflow-task-cover'
+        ? WORKFLOW_TASK_COVER_PROJECTION_RANK
+        : coverage === 'workflow'
+            ? WORKFLOW_PROJECTION_RANK
+            : coverage === 'task-cover'
+                ? TASK_COVER_PROJECTION_RANK
+                : coverage === 'planning-order'
+                    ? PLANNING_ORDER_PROJECTION_RANK
+                    : coverage === 'nested'
+                        ? NESTED_PROJECTION_RANK
+                        : COMBINED_PROJECTION_RANK;
     const rank = ranks.get(entry.projection);
     if (rank === undefined)
         throw new Error(`Unsupported combined repair projection: ${entry.projection}.`);
@@ -223,8 +228,7 @@ export function listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId) {
 export function listWorkspaceSyncV3TaskCoverRepairCandidates(core, workspaceId) {
     return listNestedRepairCandidates(core, workspaceId, 'task-attachment-links/full-v2');
 }
-/** Candidate v5 inventory. Coverage-v3/v4 inventories intentionally remain unchanged. */
-export function listWorkspaceSyncV3WorkflowRepairCandidates(core, workspaceId) {
+function listWorkflowRuntimeRepairCandidates(core, workspaceId) {
     const workflowStore = new WorkflowStore(core.getDatabaseAdapter(), core.getTenantId());
     const executions = workflowStore.listExecutions(workspaceId).map((execution) => {
         const projected = workflowStore.getProjectedExecution(workspaceId, execution.id);
@@ -265,12 +269,25 @@ export function listWorkspaceSyncV3WorkflowRepairCandidates(core, workspaceId) {
         };
     });
     return [
-        ...listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId),
         ...definitions.values(),
         ...executionCandidates,
         ...events,
     ];
 }
+/** Candidate v5 inventory. Coverage-v3/v4 inventories intentionally remain unchanged. */
+export function listWorkspaceSyncV3WorkflowRepairCandidates(core, workspaceId) {
+    return [
+        ...listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId),
+        ...listWorkflowRuntimeRepairCandidates(core, workspaceId),
+    ];
+}
+/** Candidate v8 inventory. It composes v7 task-cover state with workflow runtime. */
+export function listWorkspaceSyncV3WorkflowTaskCoverRepairCandidates(core, workspaceId) {
+    return [
+        ...listWorkspaceSyncV3TaskCoverRepairCandidates(core, workspaceId),
+        ...listWorkflowRuntimeRepairCandidates(core, workspaceId),
+    ];
+}
 /** Candidate v6 inventory. Workflow v5 remains an independent dark contract. */
 export function listWorkspaceSyncV3PlanningOrderRepairCandidates(core, workspaceId) {
     const nested = listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId);
@@ -490,26 +507,30 @@ export function buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates(i
         .map((candidate) => candidate.entityId);
     const taskFullProvenance = readTaskFullProvenanceRows({ db, tenantId, workspaceId, taskIds: remappedTaskIds });
     const provenanceCompletedAt = Date.now();
-    const entries = inventory.map((candidate) => entry(candidate, rows.get(`${candidate.domain}\0${candidate.entityId}`), taskFullProvenance, input.taskCoverCoverage === true));
+    const entries = inventory.map((candidate) => entry(candidate, rows.get(`${candidate.domain}\0${candidate.entityId}`), taskFullProvenance, input.taskCoverCoverage === true || input.workflowTaskCoverCoverage === true));
     const entriesCompletedAt = Date.now();
-    const coverage = input.workflowCoverage
-        ? 'workflow'
-        : input.taskCoverCoverage
-            ? 'task-cover'
-            : input.planningOrderCoverage
-                ? 'planning-order'
-                : input.nestedCoverage
-                    ? 'nested'
-                    : 'combined';
-    entries.forEach(coverage === 'workflow'
-        ? validateWorkspaceSyncV3WorkflowCoverageFeedEntry
-        : coverage === 'task-cover'
-            ? validateWorkspaceSyncV3TaskCoverCoverageFeedEntry
-            : coverage === 'planning-order'
-                ? validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry
-                : coverage === 'nested'
-                    ? validateWorkspaceSyncV3NestedCoverageFeedEntry
-                    : validateWorkspaceSyncV3CombinedFeedEntry);
+    const coverage = input.workflowTaskCoverCoverage
+        ? 'workflow-task-cover'
+        : input.workflowCoverage
+            ? 'workflow'
+            : input.taskCoverCoverage
+                ? 'task-cover'
+                : input.planningOrderCoverage
+                    ? 'planning-order'
+                    : input.nestedCoverage
+                        ? 'nested'
+                        : 'combined';
+    entries.forEach(coverage === 'workflow-task-cover'
+        ? validateWorkspaceSyncV3WorkflowTaskCoverCoverageFeedEntry
+        : coverage === 'workflow'
+            ? validateWorkspaceSyncV3WorkflowCoverageFeedEntry
+            : coverage === 'task-cover'
+                ? validateWorkspaceSyncV3TaskCoverCoverageFeedEntry
+                : coverage === 'planning-order'
+                    ? validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry
+                    : coverage === 'nested'
+                        ? validateWorkspaceSyncV3NestedCoverageFeedEntry
+                        : validateWorkspaceSyncV3CombinedFeedEntry);
     const validationCompletedAt = Date.now();
     if (entries.some((candidate) => BigInt(candidate.sequence) > BigInt(snapshotSequence))) {
         throw new Error('Combined repair entry exceeds the locked snapshot sequence.');
@@ -601,3 +622,21 @@ export function buildWorkspaceSyncV3TaskCoverRepairSnapshot(input) {
         });
     })();
 }
+export function buildWorkspaceSyncV3WorkflowTaskCoverRepairSnapshot(input) {
+    const workspaceId = String(input.workspaceId || '').trim();
+    if (!workspaceId)
+        throw new Error('Workspace id is required.');
+    const tenantId = input.core.getTenantId();
+    const db = input.core.getDatabaseAdapter();
+    return db.transaction(() => {
+        const snapshotSequence = lockAndReadHighWatermark(db, tenantId, workspaceId);
+        const inventory = listWorkspaceSyncV3WorkflowTaskCoverRepairCandidates(input.core, workspaceId);
+        return buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates({
+            core: input.core,
+            workspaceId,
+            snapshotSequence,
+            inventory,
+            workflowTaskCoverCoverage: true,
+        });
+    })();
+}

package/dist/sync/v3/workspaceSyncV3CombinedWireContract.d.ts

@@ -3,6 +3,7 @@ import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR } from './workspaceSyncV3Nes
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR } from './workspaceSyncV3WorkflowWireContract.js';
 import { WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR } from './workspaceSyncV3PlanningOrderWireContract.js';
 import { WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR } from './workspaceSyncV3TaskCoverWireContract.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR } from './workspaceSyncV3WorkflowTaskCoverWireContract.js';
 export declare const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR: Readonly<{
     coverageProfileId: "task-planning-metadata";
     coverageVersion: 3;
@@ -10,7 +11,7 @@ export declare const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR: Readonly<{
 }>;
 export declare const WORKSPACE_SYNC_V3_COMBINED_CAPABILITY_VERSION: 1;
 export declare const WORKSPACE_SYNC_V3_COMBINED_EXCLUDED_V2_PROJECTIONS: readonly ["task/root-v1", "task-relationship/full-v1", "taxonomy/full-v1", "initiative/full-v1", "workstream/full-v1"];
-export type WorkspaceSyncV3CombinedCoverageSelector = typeof WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR;
+export type WorkspaceSyncV3CombinedCoverageSelector = typeof WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR;
 export interface WorkspaceSyncV3CombinedWireContract {
     coverage: WorkspaceSyncV3CombinedCoverageSelector;
     excludedProjections: readonly WorkspaceSyncV2ProjectionExclusion[];

package/dist/sync/v3/workspaceSyncV3CombinedWireContract.js

@@ -2,6 +2,7 @@ import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR, WORKSPACE_SYNC_V3_NESTED_EX
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR, WORKSPACE_SYNC_V3_WORKFLOW_EXCLUDED_V2_PROJECTIONS, } from './workspaceSyncV3WorkflowWireContract.js';
 import { WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR, WORKSPACE_SYNC_V3_PLANNING_ORDER_EXCLUDED_V2_PROJECTIONS, } from './workspaceSyncV3PlanningOrderWireContract.js';
 import { WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR, WORKSPACE_SYNC_V3_TASK_COVER_EXCLUDED_V2_PROJECTIONS, } from './workspaceSyncV3TaskCoverWireContract.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR, WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_EXCLUDED_V2_PROJECTIONS, } from './workspaceSyncV3WorkflowTaskCoverWireContract.js';
 export const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR = Object.freeze({
     coverageProfileId: 'task-planning-metadata',
     coverageVersion: 3,
@@ -79,9 +80,24 @@ export function resolveWorkspaceSyncV3CombinedWireContract(input) {
             taskCoverProjectionRequired: true,
         };
     }
+    if (profileId === WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR.coverageProfileId
+        && version === WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR.coverageVersion
+        && digest === WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR.coverageDigest) {
+        return {
+            coverage: WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR,
+            excludedProjections: WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_EXCLUDED_V2_PROJECTIONS,
+            nestedWriterPrerequisitesRequired: true,
+            workflowWriterPrerequisitesRequired: true,
+            planningOrderWriterPrerequisitesRequired: false,
+            taskCoverProjectionRequired: true,
+        };
+    }
     return null;
 }
 export function resolveWorkspaceSyncV3CombinedCoverageForExclusions(exclusions) {
+    // V8 deliberately shares V7's v2 exclusions. Exclusions alone therefore
+    // identify the active V7 boundary; V8 activation must carry its exact
+    // persisted selector instead of using this legacy reverse lookup.
     for (const coverage of [
         WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR,
         WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR,

package/dist/sync/v3/workspaceSyncV3CoverageRegistry.js

@@ -3,6 +3,7 @@ import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_POLICY, WORKSPACE_SYNC_V3_NESTED_COVE
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_POLICY, WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE, validateWorkspaceSyncV3WorkflowCoverageFeedEntry, } from './workspaceSyncV3WorkflowCoverage.js';
 import { WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_POLICY, WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE, validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry, } from './workspaceSyncV3PlanningOrderCoverage.js';
 import { WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_POLICY, WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE, validateWorkspaceSyncV3TaskCoverCoverageFeedEntry, } from './workspaceSyncV3TaskCoverCoverage.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_POLICY, WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE, validateWorkspaceSyncV3WorkflowTaskCoverCoverageFeedEntry, } from './workspaceSyncV3WorkflowTaskCoverCoverage.js';
 export const WORKSPACE_SYNC_V3_REGISTERED_COVERAGES = Object.freeze([
     Object.freeze({
         profile: WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE,
@@ -29,6 +30,11 @@ export const WORKSPACE_SYNC_V3_REGISTERED_COVERAGES = Object.freeze([
         policy: WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_POLICY,
         validateEntry: validateWorkspaceSyncV3TaskCoverCoverageFeedEntry,
     }),
+    Object.freeze({
+        profile: WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE,
+        policy: WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_POLICY,
+        validateEntry: validateWorkspaceSyncV3WorkflowTaskCoverCoverageFeedEntry,
+    }),
 ]);
 export function resolveWorkspaceSyncV3RegisteredCoverage(input) {
     const profileId = String(input.coverageProfileId || '').trim();

package/dist/sync/v3/workspaceSyncV3Feed.d.ts

@@ -34,6 +34,7 @@ export interface WorkspaceSyncV3FeedProjectionInput {
     rows: readonly WorkspaceSyncJournalRow[];
     cycleHighWatermark: string;
     followingRow?: WorkspaceSyncJournalRow | null;
+    workspaceId: string;
 }
 export type WorkspaceSyncV3FeedOperationProjector = (input: WorkspaceSyncV3FeedProjectionInput) => WorkspaceSyncV3FeedEntry[];
 export interface WorkspaceSyncV3FeedCoveragePolicy {

package/dist/sync/v3/workspaceSyncV3Feed.js

@@ -207,7 +207,12 @@ export function buildWorkspaceSyncV3Feed(input) {
             throw new WorkspaceSyncV3FeedOperationTooLargeError(`Workspace sync operation ${clientId}/${operationId} exceeds ${MAX_OPERATION_ROWS} journal rows.`);
         }
         const groupRows = rows.slice(offset, end);
-        const groupEntries = projectOperation({ rows: groupRows, cycleHighWatermark: String(high), followingRow: rows[end] || null });
+        const groupEntries = projectOperation({
+            rows: groupRows,
+            cycleHighWatermark: String(high),
+            followingRow: rows[end] || null,
+            workspaceId: input.workspaceId,
+        });
         if (entries.length + groupEntries.length > pageSize) {
             if (!entries.length)
                 throw new WorkspaceSyncV3FeedOperationTooLargeError(`Covered operation ${clientId}/${operationId} exceeds the feed entry limit.`);

package/dist/sync/v3/workspaceSyncV3NestedTaskProjection.d.ts

@@ -49,9 +49,11 @@ export declare function projectWorkspaceSyncV3NestedTaskOperation(input: {
     rows: readonly WorkspaceSyncJournalRow[];
     cycleHighWatermark: string;
     followingRow?: WorkspaceSyncJournalRow | null;
+    workspaceId: string;
 }): WorkspaceSyncV3FeedEntry[] | null;
 export declare function projectWorkspaceSyncV3NestedTaskV2Operation(input: {
     rows: readonly WorkspaceSyncJournalRow[];
     cycleHighWatermark: string;
     followingRow?: WorkspaceSyncJournalRow | null;
+    workspaceId: string;
 }): WorkspaceSyncV3FeedEntry[] | null;

package/dist/sync/v3/workspaceSyncV3NestedTaskProjection.js

@@ -225,6 +225,34 @@ function projectNestedDependentRows(rows, attachmentProjection) {
         return [projected];
     });
 }
+function assertOperationEventWorkspace(events, workspaceId) {
+    if (events.some((event) => event.workspaceId !== workspaceId)) {
+        throw new Error('Nested task operation activity belongs to another workspace.');
+    }
+}
+function assertTaskOperationActivities(events, taskId) {
+    let membershipStarted = false;
+    let taskActivityCount = 0;
+    for (const event of events) {
+        if (event.entityType === 'task') {
+            if (membershipStarted) {
+                throw new Error('Task operation activity cannot follow workstream membership activity.');
+            }
+            if (event.entityId !== taskId || event.taskId !== taskId) {
+                throw new Error('Nested task operation event identity does not match its parent root.');
+            }
+            taskActivityCount += 1;
+            continue;
+        }
+        membershipStarted = true;
+        if (event.entityType !== 'workstream' || event.details?.taskId !== taskId) {
+            throw new Error('Task operation secondary activity does not describe workstream membership.');
+        }
+    }
+    if (taskActivityCount < 1) {
+        throw new Error('Task operation must contain primary task activity before workstream membership.');
+    }
+}
 function isSupportedNestedOnlyOperation(rows) {
     const first = rows[0];
     if (!first)
@@ -247,7 +275,7 @@ function isSupportedNestedOnlyOperation(rows) {
  * root. Apply still requires referenced parents to exist on the receiver; feed
  * only needs to project the nested rows.
  */
-function projectNestedOnlyOperation(rows, attachmentProjection) {
+function projectNestedOnlyOperation(rows, attachmentProjection, workspaceId) {
     if (!isSupportedNestedOnlyOperation(rows)) {
         throw new Error('Nested-only task operation is not an allowed repair or reconciliation shape.');
     }
@@ -259,6 +287,10 @@ function projectNestedOnlyOperation(rows, attachmentProjection) {
             throw new Error('Nested task operation dependent identity does not match its task root.');
         }
     }
+    const rawEvents = rows
+        .filter((row) => row.domain === 'entity-event')
+        .map((row) => canonicalEntityEventPayload(parsePayload(row)));
+    assertOperationEventWorkspace(rawEvents, workspaceId);
     const projected = projectNestedDependentRows(rows, attachmentProjection);
     const events = projected
         .filter((entry) => entry.domain === 'entity-event')
@@ -268,13 +300,7 @@ function projectNestedOnlyOperation(rows, attachmentProjection) {
     }
     if (taskScoped.length > 0 && events.length > 0) {
         const taskId = taskScoped[0].entityId;
-        const [primaryEvent, ...secondaryEvents] = events;
-        if (primaryEvent && (primaryEvent.entityType !== 'task' || primaryEvent.entityId !== taskId)) {
-            throw new Error('Nested task operation event identity does not match its parent root.');
-        }
-        if (secondaryEvents.some((event) => (event.entityType !== 'workstream' || event.details?.taskId !== taskId))) {
-            throw new Error('Task operation secondary activity does not describe workstream membership.');
-        }
+        assertTaskOperationActivities(events, taskId);
     }
     if (events.length > 0 && projected.at(-1)?.domain !== 'entity-event') {
         throw new Error('Nested task operation must end with entity activity.');
@@ -293,7 +319,7 @@ function projectNestedTaskOperation(input, attachmentProjection) {
     const [first, ...dependents] = input.rows;
     if (first && projectionByDomain.has(first.domain)
         && input.rows.every((row) => projectionByDomain.has(row.domain))) {
-        return projectNestedOnlyOperation(input.rows, attachmentProjection);
+        return projectNestedOnlyOperation(input.rows, attachmentProjection, input.workspaceId);
     }
     if (!first || !['task', 'initiative', 'workstream'].includes(first.domain)) {
         throw new Error('Nested task operation must begin with its v3-owned parent root.');
@@ -302,10 +328,13 @@ function projectNestedTaskOperation(input, attachmentProjection) {
         throw new Error('Nested task operation contains an unsupported dependent row.');
     }
     assertNestedDependentOrder(dependents);
+    const rawEventRows = dependents.filter((row) => row.domain === 'entity-event');
+    const rawEvents = rawEventRows.map((row) => canonicalEntityEventPayload(parsePayload(row)));
+    assertOperationEventWorkspace(rawEvents, input.workspaceId);
     const projectedDependents = projectNestedDependentRows(dependents, attachmentProjection);
     const eventRows = projectedDependents.filter((entry) => entry.domain === 'entity-event');
-    const rawEventRows = dependents.filter((row) => row.domain === 'entity-event');
-    const sentinelOnly = eventRows.length === 0 && rawEventRows.length > 0 && rawEventRows.every((row) => (canonicalEntityEventPayload(parsePayload(row)).action === 'sync-v3-repair-baseline'));
+    const sentinelOnly = eventRows.length === 0 && rawEvents.length > 0
+        && rawEvents.every((event) => event.action === 'sync-v3-repair-baseline');
     const nestedBodiesOnly = eventRows.length === 0
         && projectedDependents.length > 0
         && projectedDependents.every((entry) => entry.domain !== 'entity-event');
@@ -324,17 +353,19 @@ function projectNestedTaskOperation(input, attachmentProjection) {
     }
     const events = eventRows.map((entry) => validateWorkspaceSyncV3EntityEventPayload(entry.payload));
     const [primaryEvent, ...secondaryEvents] = events;
-    if (primaryEvent && (primaryEvent.entityType !== first.domain || primaryEvent.entityId !== first.entityId)) {
-        throw new Error('Nested task operation event identity does not match its parent root.');
-    }
     if (new Set(events.map((event) => event.id)).size !== events.length) {
         throw new Error('Nested task operation contains duplicate entity-event identities.');
     }
-    if (first.domain !== 'task' && secondaryEvents.length > 0) {
-        throw new Error('Planning-root operations cannot contain secondary entity activity.');
+    if (first.domain === 'task' && events.length > 0) {
+        assertTaskOperationActivities(events, first.entityId);
     }
-    if (first.domain === 'task' && secondaryEvents.some((event) => (event.entityType !== 'workstream' || event.details?.taskId !== first.entityId))) {
-        throw new Error('Task operation secondary activity does not describe workstream membership.');
+    else if (first.domain !== 'task') {
+        if (primaryEvent && (primaryEvent.entityType !== first.domain || primaryEvent.entityId !== first.entityId)) {
+            throw new Error('Nested task operation event identity does not match its parent root.');
+        }
+        if (secondaryEvents.length > 0) {
+            throw new Error('Planning-root operations cannot contain secondary entity activity.');
+        }
     }
     let parent;
     if (first.domain === 'task') {

package/dist/sync/v3/workspaceSyncV3OperationProtocol.d.ts

@@ -11,6 +11,7 @@ import type { WorkflowRuntimeMutationCommand } from './workflowRuntimeSync.js';
 import type { WorkspaceSyncV3OriginActor } from './workspaceSyncV3OriginActor.js';
 import type { WorkspaceSyncV3TaskCommentReconcileProvenance } from './taskCommentReconcileProvenance.js';
 import type { WorkspaceSyncEntityEventSnapshot } from '../workspaceSyncModel.js';
+import type { TaskChecklistItemUpdateIntent } from './taskChecklistMutationService.js';
 export type { WorkspaceSyncV3OriginActor } from './workspaceSyncV3OriginActor.js';
 type WorkspaceSyncV3OperationEnvelopeBase<TOperation> = {
     contractVersion: 3;
@@ -115,6 +116,8 @@ export type WorkspaceSyncV3TaskChecklistEnvelope = WorkspaceSyncV3OperationEnvel
     baseLifecycleRevision: '0';
     payload: {
         items: ChecklistItem[];
+        expectedDetailRevision?: string;
+        itemUpdateIntent?: TaskChecklistItemUpdateIntent;
         originActor?: WorkspaceSyncV3OriginActor;
     };
 }>;