@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/sync/v3/workspaceSyncV3WorkflowRuntimeApply.js

@@ -0,0 +1,143 @@
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { validateWorkflowExecutionEventSyncPayload, validateWorkflowExecutionRootSyncPayload, validateWorkflowPublishedDefinitionSyncPayload, validateWorkflowRuntimeEventHistory, } from './workflowRuntimeSync.js';
+import { validateWorkspaceSyncV3WorkflowRuntimeFeedEntry } from './workspaceSyncV3WorkflowRuntimeProjection.js';
+const WORKFLOW_PROJECTIONS = new Set([
+    'workflow-published-definition/full-v2',
+    'workflow-execution/root-v1',
+    'workflow-execution-event/full-v1',
+]);
+function compareEvents(left, right) {
+    return canonicalWorkspaceSyncJson(left) === canonicalWorkspaceSyncJson(right);
+}
+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);
+    const bySequence = new Map(local.map((event) => [event.sequenceNumber, event]));
+    for (const event of incoming) {
+        const existing = bySequence.get(event.sequenceNumber);
+        if (existing && !compareEvents(existing, event)) {
+            throw new Error('Workflow execution history diverges from authoritative cloud history.');
+        }
+        if (!existing)
+            bySequence.set(event.sequenceNumber, event);
+    }
+    const events = [...bySequence.values()].sort((left, right) => left.sequenceNumber - right.sequenceNumber);
+    if (events.length === 0 || events.some((event, index) => event.sequenceNumber !== index)) {
+        throw new Error('Workflow execution history has a missing dependency.');
+    }
+    const incomingMax = incoming.at(-1)?.sequenceNumber ?? -1;
+    return {
+        events,
+        localExtension: local.length > incomingMax + 1
+            && incoming.every((event) => compareEvents(local[event.sequenceNumber], event)),
+    };
+}
+function derivedTemplate(definition, existing) {
+    if (existing)
+        return existing;
+    return {
+        ...definition.template,
+        name: definition.version.name,
+        description: definition.version.description,
+        status: 'active',
+        createdByActorId: definition.version.createdByActorId || null,
+        updatedByActorId: definition.version.updatedByActorId || null,
+        createdAt: definition.version.createdAt,
+        updatedAt: definition.version.updatedAt,
+        deletedAt: null,
+    };
+}
+/**
+ * Builds complete workflow aggregates before any revision is accepted. A root
+ * entry is the atomic install trigger; definition and event entries only carry
+ * their independent revision coordinates.
+ */
+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 eventsByExecution = new Map();
+    for (const entry of workflowEntries) {
+        validateWorkspaceSyncV3WorkflowRuntimeFeedEntry(entry);
+        if (entry.projection === 'workflow-published-definition/full-v2') {
+            const definition = validateWorkflowPublishedDefinitionSyncPayload(entry.payload);
+            if (definitions.has(definition.version.id)) {
+                throw new Error(`Workflow definition is duplicated in one apply batch: ${definition.version.id}.`);
+            }
+            definitions.set(definition.version.id, definition);
+        }
+        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}.`);
+            }
+            roots.set(root.execution.id, root);
+        }
+        else {
+            const event = validateWorkflowExecutionEventSyncPayload(entry.payload).event;
+            const events = eventsByExecution.get(event.workflowExecutionId) || [];
+            events.push(event);
+            eventsByExecution.set(event.workflowExecutionId, events);
+        }
+    }
+    for (const executionId of eventsByExecution.keys()) {
+        if (!roots.has(executionId)) {
+            throw new Error(`Workflow event batch is missing execution root ${executionId}.`);
+        }
+    }
+    const assignments = new Map();
+    for (const [executionId, root] of roots) {
+        const local = input.store.getAssignmentForExecutionSync(input.workspaceId, executionId);
+        const definition = definitions.get(root.execution.workflowVersionId)
+            || (local ? {
+                template: {
+                    id: local.template.id,
+                    tenantId: local.template.tenantId,
+                    workspaceId: local.template.workspaceId,
+                },
+                version: local.version,
+                steps: local.steps,
+            } : null);
+        if (!definition) {
+            throw new Error(`Workflow execution ${executionId} is missing its published definition.`);
+        }
+        const merged = mergeEventHistory({
+            local: local?.events || [],
+            incoming: eventsByExecution.get(executionId) || [],
+        });
+        const execution = merged.localExtension && local
+            ? local.execution
+            : root.execution;
+        validateWorkflowRuntimeEventHistory({ execution, events: merged.events });
+        assignments.set(executionId, {
+            template: derivedTemplate(definition, input.store.getTemplate(input.workspaceId, definition.template.id)),
+            version: definition.version,
+            steps: definition.steps,
+            execution,
+            events: merged.events,
+        });
+    }
+    for (const versionId of definitions.keys()) {
+        if (![...assignments.values()].some((assignment) => assignment.version.id === versionId)
+            && !input.store.getVersion(input.workspaceId, versionId)) {
+            throw new Error(`Workflow definition ${versionId} has no execution dependency in the apply batch.`);
+        }
+    }
+    return {
+        workflowEntries,
+        executionIds: new Set(assignments.keys()),
+        applyEntry: (entry) => {
+            if (!workflowEntries.has(entry))
+                return;
+            if (entry.projection !== 'workflow-execution/root-v1')
+                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,
+            });
+        },
+    };
+}

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

@@ -0,0 +1,9 @@
+import type { WorkspaceSyncV3FeedEntry } from './workspaceSyncV3Feed.js';
+import type { WorkspaceSyncJournalRow } from './workspaceSyncJournalReader.js';
+export declare function projectWorkspaceSyncV3WorkflowRuntimeJournalRow(row: WorkspaceSyncJournalRow): WorkspaceSyncV3FeedEntry | null;
+export declare function validateWorkspaceSyncV3WorkflowRuntimeFeedEntry(entry: WorkspaceSyncV3FeedEntry): void;
+export declare function projectWorkspaceSyncV3WorkflowRuntimeOperation(input: {
+    rows: readonly WorkspaceSyncJournalRow[];
+    cycleHighWatermark: string;
+    followingRow?: WorkspaceSyncJournalRow | null;
+}): WorkspaceSyncV3FeedEntry[] | null;

package/dist/sync/v3/workspaceSyncV3WorkflowRuntimeProjection.js

@@ -0,0 +1,195 @@
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
+import { canonicalWorkspaceSyncSequence, canonicalWorkspaceSyncTimestamp, assertWorkspaceSyncV3OperationBoundary, } from './workspaceSyncV3OperationProjection.js';
+import { projectWorkspaceSyncV3NestedTaskJournalRow } from './workspaceSyncV3NestedTaskProjection.js';
+import { projectWorkspaceSyncV3TaskRootJournalRow } from './workspaceSyncV3TaskRootProjection.js';
+import { validateWorkflowExecutionEventSyncPayload, validateWorkflowExecutionRootSyncPayload, validateWorkflowPublishedDefinitionSyncPayload, } from './workflowRuntimeSync.js';
+const WORKFLOW_DOMAINS = new Set([
+    'workflow-published-definition',
+    'workflow-execution',
+    'workflow-execution-event',
+]);
+function parsePayload(row) {
+    try {
+        return JSON.parse(row.payloadJson);
+    }
+    catch {
+        throw new Error(`Workflow runtime journal payload is malformed at ${row.sequence}.`);
+    }
+}
+function assertBaseRow(row) {
+    if (row.contractVersion !== WORKSPACE_SYNC_CONTRACT_VERSION) {
+        throw new Error(`Unsupported workflow runtime journal contract at ${row.sequence}.`);
+    }
+    const sequence = canonicalWorkspaceSyncSequence(row.sequence, 'Workflow runtime journal sequence');
+    if (BigInt(sequence) < 1n)
+        throw new Error('Workflow runtime journal sequence must be positive.');
+    const entityRevision = canonicalWorkspaceSyncSequence(row.entityRevision, `Workflow runtime entity revision at ${row.sequence}`);
+    const lifecycleRevision = canonicalWorkspaceSyncSequence(row.lifecycleRevision, `Workflow runtime lifecycle revision at ${row.sequence}`);
+    if (BigInt(entityRevision) < 1n || row.contentSha256 !== null || row.sizeBytes !== null) {
+        throw new Error(`Workflow runtime journal coordinates are invalid at ${row.sequence}.`);
+    }
+    return {
+        entityRevision,
+        lifecycleRevision,
+        occurredAt: canonicalWorkspaceSyncTimestamp(row.occurredAt, `Workflow runtime occurredAt at ${row.sequence}`),
+    };
+}
+export function projectWorkspaceSyncV3WorkflowRuntimeJournalRow(row) {
+    if (!WORKFLOW_DOMAINS.has(row.domain))
+        return null;
+    const coordinates = assertBaseRow(row);
+    let projection;
+    let payload;
+    if (row.domain === 'workflow-published-definition' && row.mutationKind === 'publish') {
+        projection = 'workflow-published-definition/full-v2';
+        const definition = validateWorkflowPublishedDefinitionSyncPayload(parsePayload(row));
+        payload = definition;
+        const versionId = definition.version.id;
+        if (row.entityId !== versionId || coordinates.entityRevision !== '1'
+            || coordinates.lifecycleRevision !== '0') {
+            throw new Error(`Workflow published definition coordinates are invalid at ${row.sequence}.`);
+        }
+    }
+    else if (row.domain === 'workflow-execution'
+        && ['create', 'transition', 'complete-step'].includes(row.mutationKind)) {
+        projection = 'workflow-execution/root-v1';
+        const root = validateWorkflowExecutionRootSyncPayload(parsePayload(row));
+        payload = root;
+        if (row.entityId !== root.execution.id
+            || BigInt(coordinates.lifecycleRevision) > BigInt(coordinates.entityRevision)) {
+            throw new Error(`Workflow execution root coordinates are invalid at ${row.sequence}.`);
+        }
+    }
+    else if (row.domain === 'workflow-execution-event' && row.mutationKind === 'append') {
+        projection = 'workflow-execution-event/full-v1';
+        const event = validateWorkflowExecutionEventSyncPayload(parsePayload(row));
+        payload = event;
+        if (row.entityId !== event.event.id || coordinates.entityRevision !== '1'
+            || coordinates.lifecycleRevision !== '0') {
+            throw new Error(`Workflow execution event coordinates are invalid at ${row.sequence}.`);
+        }
+    }
+    else {
+        throw new Error(`Unsupported workflow runtime journal mutation ${row.domain}/${row.mutationKind} at ${row.sequence}.`);
+    }
+    const canonicalFingerprint = fingerprintWorkspaceSyncPayload(payload);
+    return {
+        sequence: row.sequence,
+        projection,
+        domain: row.domain,
+        entityId: row.entityId,
+        mutationKind: row.mutationKind,
+        entityRevision: coordinates.entityRevision,
+        lifecycleRevision: coordinates.lifecycleRevision,
+        canonicalFingerprint,
+        payloadFingerprint: canonicalFingerprint,
+        payload,
+        occurredAt: coordinates.occurredAt,
+    };
+}
+export function validateWorkspaceSyncV3WorkflowRuntimeFeedEntry(entry) {
+    const projected = projectWorkspaceSyncV3WorkflowRuntimeJournalRow({
+        sequence: entry.sequence,
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        clientId: 'validation-client',
+        operationId: 'validation-operation',
+        domain: entry.domain,
+        entityId: entry.entityId,
+        mutationKind: entry.mutationKind,
+        entityRevision: entry.entityRevision,
+        lifecycleRevision: entry.lifecycleRevision,
+        contentSha256: entry.contentSha256 ?? null,
+        sizeBytes: entry.sizeBytes ?? null,
+        payloadJson: canonicalWorkspaceSyncJson(entry.payload),
+        occurredAt: entry.occurredAt,
+    });
+    if (!projected || canonicalWorkspaceSyncJson(projected) !== canonicalWorkspaceSyncJson(entry)) {
+        throw new Error(`Workflow runtime feed entry is invalid at ${entry.sequence}.`);
+    }
+}
+export function projectWorkspaceSyncV3WorkflowRuntimeOperation(input) {
+    if (!input.rows.some((row) => WORKFLOW_DOMAINS.has(row.domain)))
+        return null;
+    assertWorkspaceSyncV3OperationBoundary(input);
+    const first = input.rows[0];
+    if (first.domain === 'workflow-published-definition') {
+        if (input.rows.length !== 1) {
+            throw new Error('Workflow definition publish operation must contain exactly one row.');
+        }
+        return [projectWorkspaceSyncV3WorkflowRuntimeJournalRow(first)];
+    }
+    if (first.clientId === 'sync-v3-repair' && input.rows.length === 1
+        && (first.domain === 'workflow-execution' || first.domain === 'workflow-execution-event')) {
+        return [projectWorkspaceSyncV3WorkflowRuntimeJournalRow(first)];
+    }
+    let cursor = 0;
+    const projected = [];
+    if (first.domain === 'task') {
+        const task = projectWorkspaceSyncV3TaskRootJournalRow(first);
+        if (!task || !['metadata-update', 'set-status'].includes(first.mutationKind)) {
+            throw new Error('Workflow task operation must begin with a supported task mutation.');
+        }
+        projected.push(task);
+        cursor += 1;
+        const activityEntries = [];
+        while (input.rows[cursor]?.domain === 'entity-event') {
+            const activity = projectWorkspaceSyncV3NestedTaskJournalRow(input.rows[cursor]);
+            if (!activity)
+                throw new Error('Workflow task activity is not projectable.');
+            activityEntries.push(activity);
+            cursor += 1;
+        }
+        if (activityEntries.length === 0 && first.mutationKind !== 'set-status') {
+            throw new Error('Workflow task operation must carry its task activity after the task root.');
+        }
+        const activity = activityEntries[0];
+        if (activity) {
+            const activityPayload = activity.payload;
+            if (activityPayload.entityType !== 'task' || activityPayload.entityId !== first.entityId
+                || activityPayload.taskId !== first.entityId) {
+                throw new Error('Workflow task activity identity does not match its task root.');
+            }
+        }
+        for (const dependent of activityEntries.slice(1)) {
+            const payload = dependent.payload;
+            if (payload.entityType !== 'workstream' || payload.taskId !== first.entityId) {
+                throw new Error('Workflow task dependent activity does not match its task root.');
+            }
+        }
+        projected.push(...activityEntries);
+    }
+    const carriesDefinition = input.rows[cursor]?.domain === 'workflow-published-definition';
+    if (carriesDefinition) {
+        projected.push(projectWorkspaceSyncV3WorkflowRuntimeJournalRow(input.rows[cursor]));
+        cursor += 1;
+    }
+    const rootRow = input.rows[cursor];
+    if (!rootRow || rootRow.domain !== 'workflow-execution') {
+        throw new Error('Workflow runtime operation is missing its execution root.');
+    }
+    const root = projectWorkspaceSyncV3WorkflowRuntimeJournalRow(rootRow);
+    const rootPayload = root.payload;
+    projected.push(root);
+    cursor += 1;
+    const eventRows = input.rows.slice(cursor);
+    const validEventCount = rootRow.mutationKind === 'complete-step'
+        ? eventRows.length === 2
+        : first.domain === 'task'
+            ? eventRows.length === 1 || eventRows.length === 2
+            : eventRows.length === 1;
+    if (!validEventCount
+        || eventRows.some((row) => row.domain !== 'workflow-execution-event')) {
+        throw new Error(`Workflow ${rootRow.mutationKind} operation has an invalid event suffix.`);
+    }
+    const events = eventRows.map((row) => projectWorkspaceSyncV3WorkflowRuntimeJournalRow(row));
+    const eventPayloads = events.map((entry) => entry.payload.event);
+    if (eventPayloads.some((event) => event.workflowExecutionId !== root.entityId)
+        || eventPayloads.some((event, index) => index > 0
+            && event.sequenceNumber !== eventPayloads[index - 1].sequenceNumber + 1)
+        || new Set(eventPayloads.map((event) => event.id)).size !== eventPayloads.length
+        || eventPayloads.at(-1)?.createdAt !== rootPayload.execution.updatedAt) {
+        throw new Error('Workflow runtime event suffix does not match its execution root.');
+    }
+    return [...projected, ...events];
+}

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

@@ -0,0 +1,11 @@
+export declare const WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR: Readonly<{
+    coverageProfileId: "task-planning-metadata";
+    coverageVersion: 5;
+    coverageDigest: "1227152d1998809427f8560f85c8ef2da8780d3ea697390fbaa48c9e85a97be2";
+}>;
+/**
+ * V2 has no workflow-runtime projection. V5 therefore retains the exact v4
+ * exclusion tuple while task-status activation remains the bootstrap and
+ * rollback carrier for the initial workflow assignment.
+ */
+export declare const WORKSPACE_SYNC_V3_WORKFLOW_EXCLUDED_V2_PROJECTIONS: readonly ["task/root-v1", "task-relationship/full-v1", "taxonomy/full-v1", "initiative/full-v1", "workstream/full-v1", "task-comments/full-v1", "task-checklist/full-v1", "task-attachment-links/full-v1", "entity-event/full-v1"];

package/dist/sync/v3/workspaceSyncV3WorkflowWireContract.js

@@ -0,0 +1,12 @@
+import { WORKSPACE_SYNC_V3_NESTED_EXCLUDED_V2_PROJECTIONS } from './workspaceSyncV3NestedWireContract.js';
+export const WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR = Object.freeze({
+    coverageProfileId: 'task-planning-metadata',
+    coverageVersion: 5,
+    coverageDigest: '1227152d1998809427f8560f85c8ef2da8780d3ea697390fbaa48c9e85a97be2',
+});
+/**
+ * V2 has no workflow-runtime projection. V5 therefore retains the exact v4
+ * exclusion tuple while task-status activation remains the bootstrap and
+ * rollback carrier for the initial workflow assignment.
+ */
+export const WORKSPACE_SYNC_V3_WORKFLOW_EXCLUDED_V2_PROJECTIONS = WORKSPACE_SYNC_V3_NESTED_EXCLUDED_V2_PROJECTIONS;

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

@@ -0,0 +1,4 @@
+import type { WorkspaceSyncV3FeedEntry } from './workspaceSyncV3Feed.js';
+import type { WorkspaceSyncJournalRow } from './workspaceSyncJournalReader.js';
+export declare function validateWorkspaceSyncV3WorkstreamFeedEntry(entry: WorkspaceSyncV3FeedEntry): void;
+export declare function projectWorkspaceSyncV3WorkstreamJournalRow(row: WorkspaceSyncJournalRow): WorkspaceSyncV3FeedEntry | null;

package/dist/sync/v3/workspaceSyncV3WorkstreamProjection.js

@@ -0,0 +1,98 @@
+import { serializeWorkstreamForSync } from '../planningSyncPayload.js';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION } from './syncDurabilityStore.js';
+const MUTATION_KINDS = new Set(['create', 'metadata-update', 'append-comment', 'archive', 'unarchive']);
+function sequence(value, label) {
+    const text = String(value ?? '').trim();
+    if (!/^\d+$/.test(text))
+        throw new Error(`${label} is invalid.`);
+    return BigInt(text).toString(10);
+}
+function metadataOnly(value, path = 'payload') {
+    if (Array.isArray(value))
+        return value.forEach((entry, index) => metadataOnly(entry, `${path}[${index}]`));
+    if (!value || typeof value !== 'object')
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (key === 'content' || key === 'contentBase64')
+            throw new Error(`Covered feed cannot include ${path}.${key}.`);
+        metadataOnly(child, `${path}.${key}`);
+    }
+}
+function canonicalPayload(payload, entityId, mutationKind, label) {
+    metadataOnly(payload);
+    if (!MUTATION_KINDS.has(mutationKind))
+        throw new Error(`Unsupported workstream mutation at ${label}.`);
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new Error(`Invalid workstream payload at ${label}.`);
+    }
+    const canonical = serializeWorkstreamForSync(payload);
+    if (canonical.id !== entityId || canonicalWorkspaceSyncJson(canonical) !== canonicalWorkspaceSyncJson(payload)) {
+        throw new Error(`Workstream payload is not canonical at ${label}.`);
+    }
+    if (mutationKind === 'archive' && !canonical.isArchived)
+        throw new Error(`Archive payload is active at ${label}.`);
+    if (mutationKind === 'unarchive' && canonical.isArchived)
+        throw new Error(`Unarchive payload is archived at ${label}.`);
+    if (mutationKind === 'create' && (canonical.isArchived || canonical.referenceNumber === null
+        || canonical.referenceNumber === undefined || canonical.referenceLabel !== `WS-${canonical.referenceNumber}`)) {
+        throw new Error(`Create payload lacks active canonical identity at ${label}.`);
+    }
+    return canonical;
+}
+export function validateWorkspaceSyncV3WorkstreamFeedEntry(entry) {
+    if (entry.projection !== 'workstream/full-v1' || entry.domain !== 'workstream') {
+        throw new Error('Unsupported workstream feed projection.');
+    }
+    const entityRevision = sequence(entry.entityRevision, 'Workstream entity revision');
+    const lifecycleRevision = sequence(entry.lifecycleRevision, 'Workstream lifecycle revision');
+    sequence(entry.sequence, 'Workstream sequence');
+    if (BigInt(entityRevision) < 1n || BigInt(lifecycleRevision) > BigInt(entityRevision)) {
+        throw new Error(`Workstream feed revisions are invalid at ${entry.sequence}.`);
+    }
+    if (entry.mutationKind === 'create' && (entityRevision !== '1' || lifecycleRevision !== '0')) {
+        throw new Error(`Workstream create revisions are invalid at ${entry.sequence}.`);
+    }
+    if ((entry.mutationKind === 'archive' || entry.mutationKind === 'unarchive') && BigInt(lifecycleRevision) < 1n) {
+        throw new Error(`Workstream lifecycle revision is invalid at ${entry.sequence}.`);
+    }
+    const canonical = canonicalPayload(entry.payload, entry.entityId, entry.mutationKind, entry.sequence);
+    if (fingerprintWorkspaceSyncPayload(canonical) !== entry.payloadFingerprint) {
+        throw new Error(`Workstream feed fingerprint is invalid at ${entry.sequence}.`);
+    }
+    if (entry.contentSha256 !== undefined || entry.sizeBytes !== undefined) {
+        throw new Error(`Workstream feed entry carries content coordinates at ${entry.sequence}.`);
+    }
+}
+export function projectWorkspaceSyncV3WorkstreamJournalRow(row) {
+    if (row.domain !== 'workstream')
+        return null;
+    if (row.contractVersion !== WORKSPACE_SYNC_CONTRACT_VERSION) {
+        throw new Error(`Unsupported workstream journal contract at ${row.sequence}.`);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(row.payloadJson);
+    }
+    catch {
+        throw new Error(`Malformed workstream journal payload at ${row.sequence}.`);
+    }
+    const payload = canonicalPayload(raw, row.entityId, row.mutationKind, row.sequence);
+    const entry = {
+        sequence: sequence(row.sequence, 'Workstream sequence'),
+        projection: 'workstream/full-v1',
+        domain: 'workstream',
+        entityId: row.entityId,
+        mutationKind: row.mutationKind,
+        entityRevision: sequence(row.entityRevision, 'Workstream entity revision'),
+        lifecycleRevision: sequence(row.lifecycleRevision, 'Workstream lifecycle revision'),
+        payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+        payload,
+        occurredAt: row.occurredAt,
+    };
+    if (row.contentSha256 !== null || row.sizeBytes !== null) {
+        throw new Error(`Workstream journal row carries content coordinates at ${row.sequence}.`);
+    }
+    validateWorkspaceSyncV3WorkstreamFeedEntry(entry);
+    return entry;
+}

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

@@ -0,0 +1,9 @@
+import type { WorkspaceSyncV3FeedEntry } from './workspaceSyncV3Feed.js';
+import type { WorkspaceSyncJournalRow } from './workspaceSyncJournalReader.js';
+export declare function projectWorkspaceSyncV3WorkstreamTaskOrderJournalRow(row: WorkspaceSyncJournalRow): WorkspaceSyncV3FeedEntry | null;
+export declare function projectWorkspaceSyncV3WorkstreamTaskOrderOperation(input: {
+    rows: readonly WorkspaceSyncJournalRow[];
+    cycleHighWatermark: string;
+    followingRow?: WorkspaceSyncJournalRow | null;
+}): WorkspaceSyncV3FeedEntry[] | null;
+export declare function validateWorkspaceSyncV3WorkstreamTaskOrderFeedEntry(entry: WorkspaceSyncV3FeedEntry): void;

package/dist/sync/v3/workspaceSyncV3WorkstreamTaskOrderProjection.js

@@ -0,0 +1,72 @@
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
+import { assertWorkspaceSyncV3OperationBoundary, canonicalWorkspaceSyncSequence, canonicalWorkspaceSyncTimestamp, } from './workspaceSyncV3OperationProjection.js';
+import { serializeWorkstreamTaskOrderForSync } from './workstreamTaskOrderSync.js';
+export function projectWorkspaceSyncV3WorkstreamTaskOrderJournalRow(row) {
+    if (row.domain !== 'workstream-task-order')
+        return null;
+    if (row.mutationKind !== 'replace') {
+        throw new Error(`Unsupported workstream task order mutation at ${row.sequence}.`);
+    }
+    if (row.contractVersion !== WORKSPACE_SYNC_CONTRACT_VERSION
+        || BigInt(canonicalWorkspaceSyncSequence(row.entityRevision, 'Workstream task order entity revision')) < 1n
+        || canonicalWorkspaceSyncSequence(row.lifecycleRevision, 'Workstream task order lifecycle revision') !== '0'
+        || row.contentSha256 !== null
+        || row.sizeBytes !== null) {
+        throw new Error(`Workstream task order journal coordinates are invalid at ${row.sequence}.`);
+    }
+    let source;
+    try {
+        source = JSON.parse(row.payloadJson);
+    }
+    catch {
+        throw new Error(`Workstream task order journal payload is malformed at ${row.sequence}.`);
+    }
+    const payload = serializeWorkstreamTaskOrderForSync(source);
+    if (payload.workstreamId !== row.entityId) {
+        throw new Error(`Workstream task order journal identity is invalid at ${row.sequence}.`);
+    }
+    const canonicalFingerprint = fingerprintWorkspaceSyncPayload(payload);
+    return {
+        sequence: canonicalWorkspaceSyncSequence(row.sequence, 'Workstream task order sequence'),
+        projection: 'workstream-task-order/full-v1',
+        domain: row.domain,
+        entityId: row.entityId,
+        mutationKind: row.mutationKind,
+        entityRevision: row.entityRevision,
+        lifecycleRevision: row.lifecycleRevision,
+        canonicalFingerprint,
+        payloadFingerprint: canonicalFingerprint,
+        payload,
+        occurredAt: canonicalWorkspaceSyncTimestamp(row.occurredAt, 'Workstream task order occurredAt'),
+    };
+}
+export function projectWorkspaceSyncV3WorkstreamTaskOrderOperation(input) {
+    if (!input.rows.some((row) => row.domain === 'workstream-task-order'))
+        return null;
+    assertWorkspaceSyncV3OperationBoundary(input);
+    if (input.rows.length !== 1 || input.rows[0].domain !== 'workstream-task-order') {
+        throw new Error('Workstream task order replacement must contain exactly one journal row.');
+    }
+    return [projectWorkspaceSyncV3WorkstreamTaskOrderJournalRow(input.rows[0])];
+}
+export function validateWorkspaceSyncV3WorkstreamTaskOrderFeedEntry(entry) {
+    const projected = projectWorkspaceSyncV3WorkstreamTaskOrderJournalRow({
+        sequence: entry.sequence,
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        clientId: 'validation-client',
+        operationId: 'validation-operation',
+        domain: entry.domain,
+        entityId: entry.entityId,
+        mutationKind: entry.mutationKind,
+        entityRevision: entry.entityRevision,
+        lifecycleRevision: entry.lifecycleRevision,
+        contentSha256: entry.contentSha256 ?? null,
+        sizeBytes: entry.sizeBytes ?? null,
+        payloadJson: canonicalWorkspaceSyncJson(entry.payload),
+        occurredAt: entry.occurredAt,
+    });
+    if (!projected || canonicalWorkspaceSyncJson(projected) !== canonicalWorkspaceSyncJson(entry)) {
+        throw new Error(`Workstream task order feed entry is invalid at ${entry.sequence}.`);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { type WorkspaceSyncActivityRevision } from './taskActivityJournal.js';
+export declare function validateWorkstreamActivityAuthoritativeRevision(input: {
+    response: Record<string, unknown>;
+    authoritative: Record<string, unknown>;
+    activityId: string;
+    invalid: (message: string) => Error;
+}): {
+    workstreamSequence: string;
+    operationHighWatermark: string;
+    activityRevision: WorkspaceSyncActivityRevision;
+};

package/dist/sync/v3/workstreamActivityAuthoritativeRevision.js

@@ -0,0 +1,23 @@
+import { WORKSPACE_SYNC_ENTITY_EVENT_DOMAIN, } from './taskActivityJournal.js';
+const SEQUENCE_PATTERN = /^[1-9]\d*$/;
+export function validateWorkstreamActivityAuthoritativeRevision(input) {
+    const acceptedSequence = input.response.acceptedSequence;
+    const operationHighWatermark = input.response.operationHighWatermark;
+    const workstreamSequence = input.authoritative.sequence;
+    const activityRevision = input.response.activityRevision;
+    if (typeof acceptedSequence !== 'string' || !SEQUENCE_PATTERN.test(acceptedSequence)
+        || typeof workstreamSequence !== 'string' || !SEQUENCE_PATTERN.test(workstreamSequence)
+        || acceptedSequence !== workstreamSequence
+        || typeof operationHighWatermark !== 'string' || !SEQUENCE_PATTERN.test(operationHighWatermark)
+        || !activityRevision || typeof activityRevision !== 'object'
+        || activityRevision.domain !== WORKSPACE_SYNC_ENTITY_EVENT_DOMAIN
+        || activityRevision.entityId !== input.activityId
+        || typeof activityRevision.sequence !== 'string' || !SEQUENCE_PATTERN.test(activityRevision.sequence)
+        || activityRevision.entityRevision !== '1'
+        || activityRevision.lifecycleRevision !== '0'
+        || operationHighWatermark !== activityRevision.sequence
+        || BigInt(activityRevision.sequence) !== BigInt(workstreamSequence) + 1n) {
+        throw input.invalid('Authoritative workstream and activity revisions are not in canonical sequence order.');
+    }
+    return { workstreamSequence, operationHighWatermark, activityRevision };
+}

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

@@ -0,0 +1,8 @@
+import type { WorkspaceSyncPlanningMutationKind } from '../workspaceSyncModel.js';
+export declare function buildWorkstreamActivityEventId(input: {
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    workstreamId: string;
+    mutationKind: WorkspaceSyncPlanningMutationKind;
+}): string;

package/dist/sync/v3/workstreamActivityIdentity.js

@@ -0,0 +1,14 @@
+import { createHash } from 'crypto';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+export function buildWorkstreamActivityEventId(input) {
+    const digest = createHash('sha256').update(canonicalWorkspaceSyncJson({
+        contractVersion: 3,
+        domain: 'workstream',
+        mutationKind: input.mutationKind,
+        workspaceId: String(input.workspaceId || '').trim(),
+        clientId: String(input.clientId || '').trim(),
+        operationId: String(input.operationId || '').trim(),
+        workstreamId: String(input.workstreamId || '').trim(),
+    }), 'utf8').digest('hex');
+    return `entity-event-sync-v3-${digest}`;
+}

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

@@ -0,0 +1,19 @@
+import type { WorkstreamItem } from '../../core/Taskforce.js';
+import type { WorkspaceSyncWorkstreamSnapshot } from '../workspaceSyncModel.js';
+import { WorkspaceSyncDurabilityStore, type WorkspaceSyncTaskMetadataCoexistenceDirection } from './syncDurabilityStore.js';
+export interface WorkstreamCoexistenceCore {
+    upsertWorkstreamForSync(workstream: WorkstreamItem, workspaceId?: string | null): WorkstreamItem;
+}
+export declare function applyWorkstreamSyncChangesWithCoexistence(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: WorkstreamCoexistenceCore;
+    tenantId: string;
+    workspaceId: string;
+    direction: WorkspaceSyncTaskMetadataCoexistenceDirection;
+    incomingWorkstreams: Map<string, WorkspaceSyncWorkstreamSnapshot>;
+    requiredCombinedProjectionOwner?: 'v2' | 'v3';
+    now: string;
+}): {
+    appliedIds: string[];
+    protectedIds: string[];
+};