@taskforcehq/taskforce 0.3.330 → 0.3.332

package/dist/sync/v3/workflowRuntimeMutationService.js

@@ -6,11 +6,42 @@ import { buildTaskActivityJournalEntry, serializeTaskActivityForSync, } from './
 import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
 import { buildWorkflowRuntimeEventId, buildWorkflowRuntimeTaskActivityId, } from './workflowRuntimeOperationIdentity.js';
 import { fingerprintWorkflowRuntimePayload, serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, validateWorkflowRuntimeAuthoritativeResult, validateWorkflowRuntimeMutationCommand, } from './workflowRuntimeSync.js';
+export class WorkflowRuntimeSemanticReplayError extends Error {
+    code = 'WORKFLOW_RUNTIME_SEMANTIC_REPLAY_REQUIRED';
+    statusCode = 409;
+    constructor() {
+        super('This workflow command was already completed by another synchronized runtime.');
+        this.name = 'WorkflowRuntimeSemanticReplayError';
+    }
+}
+function hasEquivalentCompletedStep(input) {
+    if (input.command.kind !== 'complete-step')
+        return false;
+    const events = input.workflowStore.listExecutionEvents(input.workspaceId, input.command.executionId);
+    const completed = events.find((event) => (event.idempotencyKey === `${input.command.idempotencyKey}:step-completed`));
+    const terminal = events.find((event) => (event.idempotencyKey === `${input.command.idempotencyKey}:step-started`
+        || event.idempotencyKey === `${input.command.idempotencyKey}:execution-completed`));
+    if (!completed || !terminal)
+        return false;
+    const evidence = completed.details.evidence;
+    const evidenceCommentId = evidence
+        && typeof evidence === 'object'
+        && !Array.isArray(evidence)
+        && evidence.type === 'comment'
+        ? String(evidence.commentId || '')
+        : '';
+    return completed.actorId === input.command.actorId
+        && terminal.actorId === input.command.actorId
+        && completed.stepId === input.command.expectedStepId
+        && evidenceCommentId === (input.command.evidenceCommentId || '');
+}
 export function prepareWorkflowRuntimeMutation(input) {
     const before = input.workflowStore.getExecutionStateSnapshot(input.workspaceId, input.command.executionId);
     if (!before)
         throw new Error('Workflow execution not found.');
     if (before.execution.status !== input.command.expectedStatus) {
+        if (hasEquivalentCompletedStep(input))
+            throw new WorkflowRuntimeSemanticReplayError();
         throw new Error('Workflow execution has advanced beyond the expected status.');
     }
     if (input.command.kind === 'complete-step' && input.command.taskTarget.taskId !== before.execution.taskId) {
@@ -191,13 +222,25 @@ export function runDurableWorkflowRuntimeMutation(input) {
             response: JSON.parse(reservation.responseJson),
         };
     }
-    const prepared = prepareWorkflowRuntimeMutation({
-        workflowStore,
-        workspaceId: input.workspaceId,
-        clientId: input.clientId,
-        operationId: input.operationId,
-        command,
-    });
+    let prepared;
+    try {
+        prepared = prepareWorkflowRuntimeMutation({
+            workflowStore,
+            workspaceId: input.workspaceId,
+            clientId: input.clientId,
+            operationId: input.operationId,
+            command,
+        });
+    }
+    catch (error) {
+        input.store.releaseFailedOperationReservation({
+            identity,
+            requestFingerprint,
+            leaseOwner: reservation.leaseOwner,
+            now: input.now,
+        });
+        throw error;
+    }
     const { before, willReassignTask, taskActivityId, eventIds } = prepared;
     const readTaskActivity = (result) => {
         const activity = result.taskActivity || input.core.getTaskEventForSync({
@@ -262,73 +305,83 @@ export function runDurableWorkflowRuntimeMutation(input) {
             },
         })),
     ];
-    const accepted = input.store.acceptReservedOperationBatch({
-        identity,
-        requestFingerprint,
-        leaseOwner: reservation.leaseOwner,
-        now: input.now,
-        entries,
-        applyMutation: () => applyPreparedWorkflowRuntimeMutation({
-            core: input.core,
-            workflowStore,
-            workspaceId: input.workspaceId,
-            command,
-            prepared,
-            now: input.now,
-        }),
-        buildResponse: (result, revisions) => {
-            const executionPayload = serializeWorkflowExecutionRootSyncPayload(result.executionResult.execution);
-            const eventPayloads = result.executionResult.events.map(serializeWorkflowExecutionEventSyncPayload);
-            const projectionRevisions = [
-                {
-                    projection: 'workflow-execution/root-v1',
-                    ...revisionFor(revisions, 'workflow-execution', command.executionId),
-                    canonicalFingerprint: fingerprintWorkflowRuntimePayload(executionPayload),
-                },
-                ...result.newEvents.map((event) => {
-                    const payload = serializeWorkflowExecutionEventSyncPayload(event);
+    const accepted = (() => {
+        try {
+            return input.store.acceptReservedOperationBatch({
+                identity,
+                requestFingerprint,
+                leaseOwner: reservation.leaseOwner,
+                now: input.now,
+                entries,
+                applyMutation: () => applyPreparedWorkflowRuntimeMutation({
+                    core: input.core,
+                    workflowStore,
+                    workspaceId: input.workspaceId,
+                    command,
+                    prepared,
+                    now: input.now,
+                }),
+                buildResponse: (result, revisions) => {
+                    const executionPayload = serializeWorkflowExecutionRootSyncPayload(result.executionResult.execution);
+                    const eventPayloads = result.executionResult.events.map(serializeWorkflowExecutionEventSyncPayload);
+                    const projectionRevisions = [
+                        {
+                            projection: 'workflow-execution/root-v1',
+                            ...revisionFor(revisions, 'workflow-execution', command.executionId),
+                            canonicalFingerprint: fingerprintWorkflowRuntimePayload(executionPayload),
+                        },
+                        ...result.newEvents.map((event) => {
+                            const payload = serializeWorkflowExecutionEventSyncPayload(event);
+                            return {
+                                projection: 'workflow-execution-event/full-v1',
+                                ...revisionFor(revisions, 'workflow-execution-event', event.id),
+                                canonicalFingerprint: fingerprintWorkflowRuntimePayload(payload),
+                            };
+                        }),
+                        ...(result.task ? [{
+                                projection: 'task/root-v1',
+                                ...revisionFor(revisions, 'task', result.task.id),
+                                canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskForSync(result.task)),
+                            }, {
+                                projection: 'entity-event/full-v1',
+                                ...revisionFor(revisions, 'entity-event', readTaskActivity(result).id),
+                                canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskActivityForSync(readTaskActivity(result))),
+                            }] : []),
+                    ].sort((left, right) => BigInt(left.sequence) < BigInt(right.sequence) ? -1 : 1);
+                    const authoritative = validateWorkflowRuntimeAuthoritativeResult({
+                        execution: executionPayload,
+                        events: eventPayloads,
+                        acceptedEventIds: result.newEvents.map((event) => event.id),
+                        ...(result.task ? {
+                            task: {
+                                payload: serializeTaskForSync(result.task),
+                                activity: serializeTaskActivityForSync(readTaskActivity(result)),
+                            },
+                        } : {}),
+                        revisions: projectionRevisions,
+                        replayed: result.executionResult.replayed,
+                    });
+                    const executionRevision = revisionFor(revisions, 'workflow-execution', command.executionId);
                     return {
-                        projection: 'workflow-execution-event/full-v1',
-                        ...revisionFor(revisions, 'workflow-execution-event', event.id),
-                        canonicalFingerprint: fingerprintWorkflowRuntimePayload(payload),
+                        success: true,
+                        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+                        workspaceId: input.workspaceId,
+                        clientId: input.clientId,
+                        operationId: input.operationId,
+                        acceptedSequence: executionRevision.sequence,
+                        operationHighWatermark: revisions.at(-1)?.sequence || executionRevision.sequence,
+                        authoritative,
                     };
-                }),
-                ...(result.task ? [{
-                        projection: 'task/root-v1',
-                        ...revisionFor(revisions, 'task', result.task.id),
-                        canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskForSync(result.task)),
-                    }, {
-                        projection: 'entity-event/full-v1',
-                        ...revisionFor(revisions, 'entity-event', readTaskActivity(result).id),
-                        canonicalFingerprint: fingerprintWorkspaceSyncPayload(serializeTaskActivityForSync(readTaskActivity(result))),
-                    }] : []),
-            ].sort((left, right) => BigInt(left.sequence) < BigInt(right.sequence) ? -1 : 1);
-            const authoritative = validateWorkflowRuntimeAuthoritativeResult({
-                execution: executionPayload,
-                events: eventPayloads,
-                acceptedEventIds: result.newEvents.map((event) => event.id),
-                ...(result.task ? {
-                    task: {
-                        payload: serializeTaskForSync(result.task),
-                        activity: serializeTaskActivityForSync(readTaskActivity(result)),
-                    },
-                } : {}),
-                revisions: projectionRevisions,
-                replayed: result.executionResult.replayed,
+                },
             });
-            const executionRevision = revisionFor(revisions, 'workflow-execution', command.executionId);
-            return {
-                success: true,
-                contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
-                workspaceId: input.workspaceId,
-                clientId: input.clientId,
-                operationId: input.operationId,
-                acceptedSequence: executionRevision.sequence,
-                operationHighWatermark: revisions.at(-1)?.sequence || executionRevision.sequence,
-                authoritative,
-            };
-        },
-    });
+        }
+        catch (error) {
+            if (hasEquivalentCompletedStep({ workflowStore, workspaceId: input.workspaceId, command })) {
+                throw new WorkflowRuntimeSemanticReplayError();
+            }
+            throw error;
+        }
+    })();
     const notify = (callback) => {
         if (!callback)
             return;

package/dist/sync/v3/workspaceSyncV3CombinedLocalApply.js

@@ -13,7 +13,7 @@ import { enqueueLocalTaskCommentReconciliation } from './localTaskCommentOutboxS
 import { buildWorkspaceSyncV3TaskCommentReconcileProvenance, indexWorkspaceSyncV3TaskCommentProvenanceEvidence, } from './taskCommentReconcileProvenance.js';
 import { serializeTaskRootForSync, } from './workspaceSyncV3TaskRootProjection.js';
 import { prepareWorkspaceSyncV3WorkflowRuntimeApply } from './workspaceSyncV3WorkflowRuntimeApply.js';
-import { serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, serializeWorkflowPublishedDefinitionSyncPayload, } from './workflowRuntimeSync.js';
+import { serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, serializeWorkflowPublishedDefinitionSyncPayload, validateWorkflowExecutionEventSyncPayload, } from './workflowRuntimeSync.js';
 import { serializeWorkstreamTaskOrderForSync } from './workstreamTaskOrderSync.js';
 import { validateWorkspaceSyncV3WorkstreamTaskOrderFeedEntry } from './workspaceSyncV3WorkstreamTaskOrderProjection.js';
 function combinedRepairBaselineMarker(page) {
@@ -198,6 +198,9 @@ function applyEntries(input) {
         store: new WorkflowStore(input.core.getDatabaseAdapter(), input.tenantId),
         workspaceId: input.workspaceId,
         entries: input.entries,
+        replaceAuthoritativeHistoryExecutionIds: input.allowAuthoritativeRevisionReset
+            ? input.authoritativeWorkflowRecoveryExecutionIds
+            : undefined,
     });
     return store.runWorkspaceDomainCoexistenceTransaction({
         tenantId: input.tenantId,
@@ -1011,7 +1014,7 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
         : [];
     const selectRecoveryEntries = (entries) => {
         const byTarget = new Map(entries.map((entry) => [`${entry.domain}\0${entry.entityId}`, entry]));
-        return recoveryTargets.map((target) => {
+        const selected = recoveryTargets.map((target) => {
             const entry = byTarget.get(`${target.domain}\0${target.entityId}`);
             if (!entry) {
                 if (!target.required)
@@ -1023,12 +1026,28 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
                 || (target.domain === 'task-attachment-links'
                     && (entry.projection === 'task-attachment-links/full-v1'
                         || entry.projection === 'task-attachment-links/full-v2'))
-                || (target.domain === 'entity-event' && entry.projection === 'entity-event/full-v1'));
+                || (target.domain === 'entity-event' && entry.projection === 'entity-event/full-v1')
+                || (target.domain === 'workflow-execution'
+                    && entry.projection === 'workflow-execution/root-v1'));
             if (!supportedTarget) {
                 throw new Error('Targeted workspace sync recovery does not support this projection.');
             }
             return entry;
         }).filter((entry) => entry !== null);
+        const workflowExecutionIds = new Set(selected
+            .filter((entry) => entry.projection === 'workflow-execution/root-v1')
+            .map((entry) => entry.entityId));
+        if (workflowExecutionIds.size > 0) {
+            for (const entry of entries) {
+                if (entry.projection !== 'workflow-execution-event/full-v1')
+                    continue;
+                const payload = validateWorkflowExecutionEventSyncPayload(entry.payload);
+                if (!workflowExecutionIds.has(payload.event.workflowExecutionId))
+                    continue;
+                selected.push(entry);
+            }
+        }
+        return selected;
     };
     const projections = coveredProjections(input.page);
     let notices = notifications();
@@ -1056,6 +1075,9 @@ export function applyWorkspaceSyncV3CombinedRepairPage(input) {
                     authoritativeEntityEventRecoveryIds: new Set(recoveryTargets
                         .filter((target) => target.domain === 'entity-event')
                         .map((target) => target.entityId)),
+                    authoritativeWorkflowRecoveryExecutionIds: new Set(recoveryTargets
+                        .filter((target) => target.domain === 'workflow-execution')
+                        .map((target) => target.entityId)),
                 } : {}),
             });
         },

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/workspaceSyncV3WorkflowRuntimeApply.d.ts

@@ -14,4 +14,5 @@ export declare function prepareWorkspaceSyncV3WorkflowRuntimeApply(input: {
     store: WorkflowStore;
     workspaceId: string;
     entries: WorkspaceSyncV3FeedEntry[];
+    replaceAuthoritativeHistoryExecutionIds?: ReadonlySet<string>;
 }): WorkspaceSyncV3WorkflowRuntimeApplyPlan;

package/dist/sync/v3/workspaceSyncV3WorkflowRuntimeApply.js

@@ -1,5 +1,5 @@
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
-import { validateWorkflowExecutionEventSyncPayload, validateWorkflowExecutionRootSyncPayload, validateWorkflowPublishedDefinitionSyncPayload, validateWorkflowRuntimeEventHistory, } from './workflowRuntimeSync.js';
+import { serializeWorkflowPublishedDefinitionSyncPayload, validateWorkflowExecutionEventSyncPayload, validateWorkflowExecutionRootSyncPayload, validateWorkflowPublishedDefinitionSyncPayload, validateWorkflowRuntimeEventHistory, } from './workflowRuntimeSync.js';
 import { validateWorkspaceSyncV3WorkflowRuntimeFeedEntry } from './workspaceSyncV3WorkflowRuntimeProjection.js';
 const WORKFLOW_PROJECTIONS = new Set([
     'workflow-published-definition/full-v2',
@@ -9,6 +9,19 @@ const WORKFLOW_PROJECTIONS = new Set([
 function compareEvents(left, right) {
     return canonicalWorkspaceSyncJson(left) === canonicalWorkspaceSyncJson(right);
 }
+function executionIdentity(root) {
+    const execution = root.execution;
+    return canonicalWorkspaceSyncJson({
+        id: execution.id,
+        tenantId: execution.tenantId,
+        workspaceId: execution.workspaceId,
+        taskId: execution.taskId,
+        workflowTemplateId: execution.workflowTemplateId,
+        workflowVersionId: execution.workflowVersionId,
+        createdByActorId: execution.createdByActorId || null,
+        createdAt: execution.createdAt,
+    });
+}
 function mergeEventHistory(input) {
     const local = [...input.local].sort((left, right) => left.sequenceNumber - right.sequenceNumber);
     const incoming = [...input.incoming].sort((left, right) => left.sequenceNumber - right.sequenceNumber);
@@ -47,6 +60,19 @@ function derivedTemplate(definition, existing) {
         deletedAt: null,
     };
 }
+function installedPublishedDefinition(store, workspaceId, versionId) {
+    const version = store.getVersion(workspaceId, versionId);
+    if (!version || version.status !== 'published')
+        return null;
+    const template = store.getTemplate(workspaceId, version.workflowTemplateId);
+    if (!template)
+        return null;
+    return serializeWorkflowPublishedDefinitionSyncPayload({
+        template,
+        version,
+        steps: store.listSteps(workspaceId, version.id),
+    });
+}
 /**
  * Builds complete workflow aggregates before any revision is accepted. A root
  * entry is the atomic install trigger; definition and event entries only carry
@@ -56,6 +82,7 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
     const workflowEntries = new Set(input.entries.filter((entry) => WORKFLOW_PROJECTIONS.has(entry.projection)));
     const definitions = new Map();
     const roots = new Map();
+    const rootEntries = new Map();
     const eventsByExecution = new Map();
     for (const entry of workflowEntries) {
         validateWorkspaceSyncV3WorkflowRuntimeFeedEntry(entry);
@@ -68,10 +95,23 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
         }
         else if (entry.projection === 'workflow-execution/root-v1') {
             const root = validateWorkflowExecutionRootSyncPayload(entry.payload);
-            if (roots.has(root.execution.id)) {
-                throw new Error(`Workflow execution root is duplicated in one apply batch: ${root.execution.id}.`);
+            const existing = roots.get(root.execution.id);
+            const existingEntry = rootEntries.get(root.execution.id);
+            if (existing && existingEntry) {
+                if (executionIdentity(existing) !== executionIdentity(root)) {
+                    throw new Error(`Workflow execution root identity changes in one apply batch: ${root.execution.id}.`);
+                }
+                const revision = BigInt(entry.entityRevision);
+                const existingRevision = BigInt(existingEntry.entityRevision);
+                if (revision === existingRevision
+                    && canonicalWorkspaceSyncJson(existing) !== canonicalWorkspaceSyncJson(root)) {
+                    throw new Error(`Workflow execution root revision conflicts in one apply batch: ${root.execution.id}.`);
+                }
+                if (revision <= existingRevision)
+                    continue;
             }
             roots.set(root.execution.id, root);
+            rootEntries.set(root.execution.id, entry);
         }
         else {
             const event = validateWorkflowExecutionEventSyncPayload(entry.payload).event;
@@ -87,6 +127,7 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
     }
     const assignments = new Map();
     for (const [executionId, root] of roots) {
+        const replaceAuthoritativeHistory = Boolean(input.replaceAuthoritativeHistoryExecutionIds?.has(executionId));
         const local = input.store.getAssignmentForExecutionSync(input.workspaceId, executionId);
         const definition = definitions.get(root.execution.workflowVersionId)
             || (local ? {
@@ -97,12 +138,13 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
                 },
                 version: local.version,
                 steps: local.steps,
-            } : null);
+            } : null)
+            || installedPublishedDefinition(input.store, input.workspaceId, root.execution.workflowVersionId);
         if (!definition) {
             throw new Error(`Workflow execution ${executionId} is missing its published definition.`);
         }
         const merged = mergeEventHistory({
-            local: local?.events || [],
+            local: replaceAuthoritativeHistory ? [] : local?.events || [],
             incoming: eventsByExecution.get(executionId) || [],
         });
         const execution = merged.localExtension && local
@@ -131,12 +173,15 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
                 return;
             if (entry.projection !== 'workflow-execution/root-v1')
                 return;
+            if (rootEntries.get(entry.entityId) !== entry)
+                return;
             const assignment = assignments.get(entry.entityId);
             if (!assignment)
                 throw new Error(`Workflow execution apply plan is missing ${entry.entityId}.`);
             input.store.installAssignmentForSync(input.workspaceId, assignment, {
                 authority: 'cloud-execution',
                 expectedTaskId: assignment.execution.taskId,
+                replaceAuthoritativeHistory: input.replaceAuthoritativeHistoryExecutionIds?.has(entry.entityId),
             });
         },
     };

package/dist/ui/assets/{AiIdentityRosterCard-OcSz1PkK.js → AiIdentityRosterCard-CDMPtnbC.js}

@@ -1 +1 @@
-import{j as i}from"./vendor-react-CKJs5o3c.js";import{t as r}from"./index-CTsDBaef.js";const t=[{name:"Blue",value:"#4269d0"},{name:"Orange",value:"#efb118"},{name:"Red",value:"#ff725c"},{name:"Cyan",value:"#6cc5b0"},{name:"Green",value:"#3ca951"},{name:"Pink",value:"#ff8ab7"},{name:"Purple",value:"#a463f2"},{name:"Light blue",value:"#97bbf5"},{name:"Brown",value:"#9c6b4e"},{name:"Gray",value:"#9498a0"}];function N(e){const s=String(e||"ai").trim().toLowerCase();let a=2166136261;for(let l=0;l<s.length;l+=1)a^=s.charCodeAt(l),a=Math.imul(a,16777619);return t[(a>>>0)%t.length].value}function b(e){const[s,a=""]=e.split("#"),n=s.includes("?")?"&":"?";return`${s}${n}taskforceCloud=1${a?`#${a}`:""}`}function $(e){return/^https?:\/\//i.test(e)?e:b(e)}function j({name:e,username:s,subtitle:a,avatar:n,selected:l,disabled:o=!1,onSelect:u,ariaLabel:c,avatarVariant:f="portrait",avatarClassName:m="",avatarStyle:d,className:p="",topUtility:h,bottomUtility:v,footer:P}){return i.jsxs("button",{type:"button",className:`${r.aiProfileGroup} ${l?r.aiProfileGroupSelected:""} ${p}`.trim(),onClick:u,disabled:o,"aria-label":c,"aria-pressed":l,children:[h,v,i.jsxs("span",{className:r.aiProfileGroupHeader,children:[i.jsx("span",{className:`${r.aiProfileGroupAvatar} ${f==="logo"?r.aiProfileGroupAvatarLogo:""} ${m}`.trim(),style:d,"aria-hidden":"true",children:n}),i.jsxs("span",{className:r.aiProfileGroupIdentity,children:[i.jsx("span",{className:r.aiProfileName,children:e}),s?i.jsxs("span",{className:r.aiProfileHandle,children:["@",s]}):null,i.jsx("span",{className:r.aiProfileRole,children:a}),P]})]})]})}export{j as A,N as a,t as b,$ as r,b as w};
+import{j as i}from"./vendor-react-CKJs5o3c.js";import{t as r}from"./index-DSQINwt9.js";const t=[{name:"Blue",value:"#4269d0"},{name:"Orange",value:"#efb118"},{name:"Red",value:"#ff725c"},{name:"Cyan",value:"#6cc5b0"},{name:"Green",value:"#3ca951"},{name:"Pink",value:"#ff8ab7"},{name:"Purple",value:"#a463f2"},{name:"Light blue",value:"#97bbf5"},{name:"Brown",value:"#9c6b4e"},{name:"Gray",value:"#9498a0"}];function N(e){const s=String(e||"ai").trim().toLowerCase();let a=2166136261;for(let l=0;l<s.length;l+=1)a^=s.charCodeAt(l),a=Math.imul(a,16777619);return t[(a>>>0)%t.length].value}function b(e){const[s,a=""]=e.split("#"),n=s.includes("?")?"&":"?";return`${s}${n}taskforceCloud=1${a?`#${a}`:""}`}function $(e){return/^https?:\/\//i.test(e)?e:b(e)}function j({name:e,username:s,subtitle:a,avatar:n,selected:l,disabled:o=!1,onSelect:u,ariaLabel:c,avatarVariant:f="portrait",avatarClassName:m="",avatarStyle:d,className:p="",topUtility:h,bottomUtility:v,footer:P}){return i.jsxs("button",{type:"button",className:`${r.aiProfileGroup} ${l?r.aiProfileGroupSelected:""} ${p}`.trim(),onClick:u,disabled:o,"aria-label":c,"aria-pressed":l,children:[h,v,i.jsxs("span",{className:r.aiProfileGroupHeader,children:[i.jsx("span",{className:`${r.aiProfileGroupAvatar} ${f==="logo"?r.aiProfileGroupAvatarLogo:""} ${m}`.trim(),style:d,"aria-hidden":"true",children:n}),i.jsxs("span",{className:r.aiProfileGroupIdentity,children:[i.jsx("span",{className:r.aiProfileName,children:e}),s?i.jsxs("span",{className:r.aiProfileHandle,children:["@",s]}):null,i.jsx("span",{className:r.aiProfileRole,children:a}),P]})]})]})}export{j as A,N as a,t as b,$ as r,b as w};