@taskforcehq/taskforce 0.3.327 → 0.3.328

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

@@ -7,6 +7,7 @@ export declare function prepareWorkspaceSyncV3CombinedRepairSnapshot(input: {
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
     planningOrderCoverage?: boolean;
+    coveredLegacyWritesFenced?: boolean;
 }): {
     highWatermark: string;
     insertedEntities: number;
@@ -20,16 +21,19 @@ export declare function prepareWorkspaceSyncV3NestedRepairSnapshot(input: {
     core: TaskforceCore;
     workspaceId: string;
     now?: string;
+    coveredLegacyWritesFenced?: boolean;
 }): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
 export declare function prepareWorkspaceSyncV3WorkflowRepairSnapshot(input: {
     core: TaskforceCore;
     workspaceId: string;
     now?: string;
+    coveredLegacyWritesFenced?: boolean;
 }): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
 export declare function prepareWorkspaceSyncV3PlanningOrderRepairSnapshot(input: {
     core: TaskforceCore;
     workspaceId: string;
     now?: string;
+    coveredLegacyWritesFenced?: boolean;
 }): ReturnType<typeof prepareWorkspaceSyncV3CombinedRepairSnapshot>;
 export declare function ensureWorkspaceSyncV3CombinedRepairBaselines(input: {
     core: TaskforceCore;

package/dist/sync/v3/workspaceSyncV3CombinedRepairBaseline.js

@@ -12,7 +12,7 @@ import { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceS
 import { projectWorkspaceSyncV3NestedTaskJournalRow } from './workspaceSyncV3NestedTaskProjection.js';
 import { serializeTaskRelationshipForSync } from './workspaceSyncV3TaskRelationshipProjection.js';
 import { projectWorkspaceSyncV3TaskRootJournalRow, serializeTaskRootForSync, } from './workspaceSyncV3TaskRootProjection.js';
-const SQL_BATCH_SIZE = 400;
+import { workspaceSyncV3RepairEntityReadBatchSize } from './workspaceSyncV3RepairSqlBatching.js';
 const BASELINE_CLIENT_ID = 'sync-v3-repair';
 const LEGACY_REPAIRABLE_NESTED_DOMAINS = new Set([
     'task-comments', 'task-checklist', 'task-attachment-links',
@@ -84,10 +84,11 @@ function lifecycleState(candidate) {
 function readRevisions(input) {
     const result = new Map();
     const db = input.core.getDatabaseAdapter();
+    const batchSize = workspaceSyncV3RepairEntityReadBatchSize(db);
     for (const domain of [...new Set(input.candidates.map((candidate) => candidate.domain))]) {
         const ids = input.candidates.filter((candidate) => candidate.domain === domain).map((candidate) => candidate.entityId);
-        for (let offset = 0; offset < ids.length; offset += SQL_BATCH_SIZE) {
-            const batch = ids.slice(offset, offset + SQL_BATCH_SIZE);
+        for (let offset = 0; offset < ids.length; offset += batchSize) {
+            const batch = ids.slice(offset, offset + batchSize);
             const placeholders = batch.map(() => '?').join(', ');
             const rows = db.prepare(`
                 SELECT entity_id, contract_version,
@@ -250,6 +251,7 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
     const tenantId = input.core.getTenantId();
     const db = input.core.getDatabaseAdapter();
     return db.transaction(() => {
+        const startedAt = Date.now();
         const lock = db.prepare(`
             INSERT INTO workspace_sync_sequences (tenant_id, workspace_id, last_sequence, updated_at)
             VALUES (?, ?, 0, ?)
@@ -257,6 +259,7 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
             RETURNING CAST(last_sequence AS TEXT) AS last_sequence
         `).get(tenantId, workspaceId, now);
         sequence(lock?.last_sequence);
+        const lockCompletedAt = Date.now();
         const candidates = input.workflowCoverage
             ? listWorkspaceSyncV3WorkflowRepairCandidates(input.core, workspaceId)
             : input.planningOrderCoverage
@@ -264,10 +267,12 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
                 : input.nestedCoverage
                     ? listWorkspaceSyncV3NestedRepairCandidates(input.core, workspaceId)
                     : listWorkspaceSyncV3CombinedRepairCandidates(input.core, workspaceId);
+        const inventoryCompletedAt = Date.now();
         const keys = candidates.map((candidate) => `${candidate.domain}\0${candidate.entityId}`);
         if (new Set(keys).size !== keys.length)
             throw new Error('Combined repair baseline contains duplicate entities.');
         const revisions = readRevisions({ core: input.core, tenantId, workspaceId, candidates });
+        const revisionsCompletedAt = Date.now();
         const missing = [];
         const legacyRelationshipSkews = [];
         const legacyNestedDrifts = [];
@@ -383,6 +388,7 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
                 });
             }
         }
+        const validationCompletedAt = Date.now();
         const rowCount = legacyRelationshipSkews.length + legacyNestedDrifts.length + missing.reduce((count, candidate) => {
             if (candidate.domain === 'workflow-published-definition'
                 || candidate.domain === 'workflow-execution'
@@ -541,6 +547,7 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
             if (Number(updated.changes) !== 1)
                 throw repairConflict('legacy-nested-repair-raced', repair.candidate);
         }
+        const baselineWritesCompletedAt = Date.now();
         const profile = input.workflowCoverage
             ? WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE
             : input.planningOrderCoverage
@@ -557,9 +564,10 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
         `).get(tenantId, workspaceId, WORKSPACE_SYNC_COMBINED_PROJECTION, WORKSPACE_SYNC_CONTRACT_VERSION, profile.coverageProfileId, profile.coverageVersion, profile.coverageDigest);
         // Exact active v3 ownership closes every ordinary writer over the same
         // sequence lock, so the inventory read above remains the authoritative
-        // cut. Activation repair still re-inventories because legacy/v2 writers
-        // do not reserve that lock and could otherwise create undetectable drift.
-        const snapshot = activeOwner?.active === 1
+        // cut. The cloud activation route may attest the same invariant by
+        // fencing covered legacy/v2 writers. Unfenced rollback repair still
+        // re-inventories because those writers do not reserve this lock.
+        const snapshot = activeOwner?.active === 1 || input.coveredLegacyWritesFenced === true
             ? buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates({
                 core: input.core,
                 workspaceId,
@@ -576,9 +584,24 @@ export function prepareWorkspaceSyncV3CombinedRepairSnapshot(input) {
                     : input.nestedCoverage
                         ? buildWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId })
                         : buildWorkspaceSyncV3CombinedRepairSnapshot({ core: input.core, workspaceId });
+        const snapshotCompletedAt = Date.now();
         if (snapshot.snapshotSequence !== highWatermark) {
             throw new Error('Combined repair baseline snapshot sequence changed while locked.');
         }
+        console.info('[Taskforce Sync Repair Baseline Timing]', JSON.stringify({
+            workspaceId,
+            coverage: input.workflowCoverage ? 'workflow'
+                : input.planningOrderCoverage ? 'planning-order'
+                    : input.nestedCoverage ? 'nested' : 'combined',
+            candidates: candidates.length,
+            lock: lockCompletedAt - startedAt,
+            inventory: inventoryCompletedAt - lockCompletedAt,
+            revisions: revisionsCompletedAt - inventoryCompletedAt,
+            validation: validationCompletedAt - revisionsCompletedAt,
+            baselineWrites: baselineWritesCompletedAt - validationCompletedAt,
+            snapshot: snapshotCompletedAt - baselineWritesCompletedAt,
+            total: snapshotCompletedAt - startedAt,
+        }));
         return { highWatermark, insertedEntities: missing.length + legacyRelationshipSkews.length + legacyNestedDrifts.length,
             insertedJournalRows: rowCount, snapshot };
     })();

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

@@ -59,6 +59,7 @@ export declare function buildWorkspaceSyncV3CombinedRepairPage(input: {
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
     planningOrderCoverage?: boolean;
+    coveredLegacyWritesFenced?: boolean;
 }): WorkspaceSyncV3CombinedRepairPage;
 export declare function buildWorkspaceSyncV3NestedRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage'>): WorkspaceSyncV3CombinedRepairPage;
 export declare function buildWorkspaceSyncV3WorkflowRepairPage(input: Omit<Parameters<typeof buildWorkspaceSyncV3CombinedRepairPage>[0], 'nestedCoverage' | 'workflowCoverage' | 'planningOrderCoverage'>): WorkspaceSyncV3CombinedRepairPage;

package/dist/sync/v3/workspaceSyncV3CombinedRepairMaterialization.js

@@ -14,7 +14,11 @@ const MAX_PAGE_SIZE = 100;
 const DEFAULT_MAX_RESPONSE_BYTES = 1024 * 1024;
 const DEFAULT_SNAPSHOT_TTL_MS = 60 * 60_000;
 const MAX_SNAPSHOT_TTL_MS = 24 * 60 * 60_000;
-const INSERT_BATCH_SIZE = 50;
+const SQLITE_INSERT_BATCH_SIZE = 50;
+// Postgres permits 65,535 bind parameters. Each materialized entry uses 15,
+// so 1,000 entries keeps a wide safety margin while avoiding hundreds of
+// synchronous worker/database round trips for large repair snapshots.
+const POSTGRES_INSERT_BATCH_SIZE = 1000;
 export class WorkspaceSyncV3CombinedRepairSnapshotUnavailableError extends Error {
     code = 'WORKSPACE_SYNC_V3_COMBINED_REPAIR_SNAPSHOT_UNAVAILABLE';
     statusCode = 410;
@@ -170,8 +174,11 @@ function persistMaterialization(input) {
             coverage_version, coverage_digest, snapshot_sequence, entry_count, created_at, expires_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(input.tenantId, input.workspaceId, snapshotId, WORKSPACE_SYNC_CONTRACT_VERSION, profile.coverageProfileId, profile.coverageVersion, profile.coverageDigest, snapshot.snapshotSequence, snapshot.entries.length, input.startedAt, provisionalExpiresAt);
-    for (let offset = 0; offset < snapshot.entries.length; offset += INSERT_BATCH_SIZE) {
-        const batch = snapshot.entries.slice(offset, offset + INSERT_BATCH_SIZE);
+    const insertBatchSize = db.provider === 'postgres'
+        ? POSTGRES_INSERT_BATCH_SIZE
+        : SQLITE_INSERT_BATCH_SIZE;
+    for (let offset = 0; offset < snapshot.entries.length; offset += insertBatchSize) {
+        const batch = snapshot.entries.slice(offset, offset + insertBatchSize);
         const values = batch.map(() => '(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)').join(', ');
         const args = [];
         batch.forEach((entry, index) => args.push(input.tenantId, input.workspaceId, snapshotId, offset + index, entry.projection, entry.domain, entry.entityId, entry.sequence, entry.mutationKind, entry.entityRevision, entry.lifecycleRevision, entry.canonicalFingerprint ?? null, entry.payloadFingerprint, canonicalWorkspaceSyncJson(entry.payload), entry.occurredAt));
@@ -414,18 +421,24 @@ export function buildWorkspaceSyncV3CombinedRepairPage(input) {
             if (reusable)
                 return { metadata: reusable, reused: true,
                     insertedBaselineEntities: 0, insertedBaselineJournalRows: 0 };
+            const repairStartedAt = Date.now();
             const prepared = coverage === 'workflow'
-                ? prepareWorkspaceSyncV3WorkflowRepairSnapshot({ core: input.core, workspaceId, now })
+                ? prepareWorkspaceSyncV3WorkflowRepairSnapshot({ core: input.core, workspaceId, now,
+                    coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
                 : coverage === 'planning-order'
-                    ? prepareWorkspaceSyncV3PlanningOrderRepairSnapshot({ core: input.core, workspaceId, now })
+                    ? prepareWorkspaceSyncV3PlanningOrderRepairSnapshot({ core: input.core, workspaceId, now,
+                        coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
                     : coverage === 'nested'
-                        ? prepareWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId, now })
-                        : prepareWorkspaceSyncV3CombinedRepairSnapshot({ core: input.core, workspaceId, now });
+                        ? 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
                 ? now
                 : timestamp(new Date().toISOString(), 'Combined repair materialization start time');
+            const persistenceStartedAt = Date.now();
             const persisted = persistMaterialization({
                 core: input.core, tenantId, workspaceId, startedAt: materializationStartedAt,
                 fixedCompletionTime: input.now ? now : undefined, ttlMs,
@@ -434,6 +447,15 @@ export function buildWorkspaceSyncV3CombinedRepairPage(input) {
                 insertedBaselineJournalRows: prepared.insertedJournalRows,
                 coverage,
             });
+            console.info('[Taskforce Sync Repair Timing]', JSON.stringify({
+                workspaceId,
+                coverage,
+                entries: prepared.snapshot.entries.length,
+                insertedBaselineEntities: prepared.insertedEntities,
+                insertedBaselineJournalRows: prepared.insertedJournalRows,
+                persistence: Date.now() - persistenceStartedAt,
+                endToEnd: Date.now() - repairStartedAt,
+            }));
             return { metadata: persisted, reused: false,
                 insertedBaselineEntities: prepared.insertedEntities,
                 insertedBaselineJournalRows: prepared.insertedJournalRows };

package/dist/sync/v3/workspaceSyncV3CombinedRepairSnapshot.js

@@ -18,8 +18,8 @@ import { projectWorkspaceSyncV3WorkstreamTaskOrderJournalRow } from './workspace
 import { serializeWorkstreamTaskOrderForSync } from './workstreamTaskOrderSync.js';
 import { serializeTaxonomyStateForSync } from './taxonomySyncPayload.js';
 import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION } from './syncDurabilityStore.js';
+import { workspaceSyncV3RepairEntityReadBatchSize } from './workspaceSyncV3RepairSqlBatching.js';
 const READ_PAGE_SIZE = 1000;
-const SQL_BATCH_SIZE = 400;
 const COMBINED_PROJECTION_RANK = new Map(WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE.projections
     .map((projection, index) => [projection.projectionId, index]));
 const NESTED_PROJECTION_RANK = new Map(WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE.projections
@@ -53,6 +53,9 @@ function projectionRank(entry, coverage) {
     return rank;
 }
 function listTasks(core, workspaceId) {
+    if (typeof core.listTasksForAuthoritativeRepair === 'function') {
+        return core.listTasksForAuthoritativeRepair(workspaceId);
+    }
     const result = [];
     let cursor = null;
     for (;;) {
@@ -150,18 +153,27 @@ function listLiveEvents(core, workspaceId, liveEntityIds) {
 }
 /** Candidate v4 inventory. The coverage-v3 inventory above intentionally remains unchanged. */
 export function listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId) {
+    const startedAt = Date.now();
     const tasks = listTasks(core, workspaceId);
+    const tasksCompletedAt = Date.now();
     const relationships = listRelationships(core, workspaceId);
+    const relationshipsCompletedAt = Date.now();
     const initiatives = listInitiatives(core, workspaceId);
+    const initiativesCompletedAt = Date.now();
     const workstreams = listWorkstreams(core, workspaceId);
+    const workstreamsCompletedAt = Date.now();
     const taxonomy = serializeTaxonomyStateForSync(core.getTaxonomyState(workspaceId));
+    const taxonomyCompletedAt = Date.now();
     const liveEntityIds = new Set([
         ...tasks.map((task) => `task\0${task.id}`),
         ...initiatives.map((candidate) => `initiative\0${candidate.entityId}`),
         ...workstreams.map((candidate) => `workstream\0${candidate.entityId}`),
     ]);
     const attachmentLinksByTaskId = core.listWorkspaceTaskAttachmentLinksForDurableSync(new Set(tasks.map((task) => task.id)), workspaceId);
-    return [
+    const attachmentLinksCompletedAt = Date.now();
+    const events = listLiveEvents(core, workspaceId, liveEntityIds);
+    const eventsCompletedAt = Date.now();
+    const candidates = [
         ...tasks.map((task) => ({
             domain: 'task', entityId: task.id, payload: serializeTaskRootForSync(task),
         })),
@@ -171,10 +183,32 @@ export function listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId) {
         ...workstreams,
         ...buildWorkspaceSyncV3NestedTaskRepairCandidates({
             tasks,
-            events: listLiveEvents(core, workspaceId, liveEntityIds),
+            events,
             attachmentLinksByTaskId,
         }),
     ];
+    const completedAt = Date.now();
+    if (completedAt - startedAt >= 1_000) {
+        console.info('[Taskforce Sync Repair Inventory Timing]', JSON.stringify({
+            workspaceId,
+            tasks: tasks.length,
+            relationships: relationships.length,
+            initiatives: initiatives.length,
+            workstreams: workstreams.length,
+            events: events.length,
+            candidates: candidates.length,
+            listTasks: tasksCompletedAt - startedAt,
+            listRelationships: relationshipsCompletedAt - tasksCompletedAt,
+            listInitiatives: initiativesCompletedAt - relationshipsCompletedAt,
+            listWorkstreams: workstreamsCompletedAt - initiativesCompletedAt,
+            taxonomy: taxonomyCompletedAt - workstreamsCompletedAt,
+            attachmentLinks: attachmentLinksCompletedAt - taxonomyCompletedAt,
+            listEvents: eventsCompletedAt - attachmentLinksCompletedAt,
+            serializeCandidates: completedAt - eventsCompletedAt,
+            total: completedAt - startedAt,
+        }));
+    }
+    return candidates;
 }
 /** Candidate v5 inventory. Coverage-v3/v4 inventories intentionally remain unchanged. */
 export function listWorkspaceSyncV3WorkflowRepairCandidates(core, workspaceId) {
@@ -258,10 +292,11 @@ function journalRow(row) {
 }
 function readLastRows(db, tenantId, workspaceId, inventory) {
     const result = new Map();
+    const batchSize = workspaceSyncV3RepairEntityReadBatchSize(db);
     for (const domain of [...new Set(inventory.map((candidate) => candidate.domain))]) {
         const ids = inventory.filter((candidate) => candidate.domain === domain).map((candidate) => candidate.entityId);
-        for (let offset = 0; offset < ids.length; offset += SQL_BATCH_SIZE) {
-            const batch = ids.slice(offset, offset + SQL_BATCH_SIZE);
+        for (let offset = 0; offset < ids.length; offset += batchSize) {
+            const batch = ids.slice(offset, offset + batchSize);
             const placeholders = batch.map(() => '?').join(', ');
             const rows = db.prepare(`
                 SELECT journal.*
@@ -284,8 +319,9 @@ function readLastRows(db, tenantId, workspaceId, inventory) {
 }
 function readTaskFullProvenanceRows(input) {
     const result = new Map();
-    for (let offset = 0; offset < input.taskIds.length; offset += SQL_BATCH_SIZE) {
-        const batch = input.taskIds.slice(offset, offset + SQL_BATCH_SIZE);
+    const batchSize = workspaceSyncV3RepairEntityReadBatchSize(input.db);
+    for (let offset = 0; offset < input.taskIds.length; offset += batchSize) {
+        const batch = input.taskIds.slice(offset, offset + batchSize);
         const placeholders = batch.map(() => '?').join(', ');
         const rows = input.db.prepare(`
             SELECT journal.*
@@ -427,7 +463,9 @@ export function buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates(i
     const tenantId = input.core.getTenantId();
     const db = input.core.getDatabaseAdapter();
     const inventory = input.inventory;
+    const startedAt = Date.now();
     const rows = readLastRows(db, tenantId, workspaceId, inventory);
+    const rowsCompletedAt = Date.now();
     const missing = inventory.filter((candidate) => !rows.has(`${candidate.domain}\0${candidate.entityId}`))
         .map((candidate) => ({ domain: candidate.domain, entityId: candidate.entityId }));
     if (missing.length > 0)
@@ -436,7 +474,9 @@ export function buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates(i
         .filter((candidate) => rows.get(`task\0${candidate.entityId}`)?.mutationKind === 'taxonomy-remap')
         .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));
+    const entriesCompletedAt = Date.now();
     const coverage = input.workflowCoverage
         ? 'workflow'
         : input.planningOrderCoverage
@@ -451,12 +491,27 @@ export function buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates(i
             : 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.');
     }
     entries.sort((left, right) => (projectionRank(left, coverage)
         - projectionRank(right, coverage))
         || compareCodeUnits(left.entityId, right.entityId));
+    const completedAt = Date.now();
+    if (completedAt - startedAt >= 1_000) {
+        console.info('[Taskforce Sync Repair Snapshot Timing]', JSON.stringify({
+            workspaceId,
+            coverage,
+            entries: entries.length,
+            readRows: rowsCompletedAt - startedAt,
+            readProvenance: provenanceCompletedAt - rowsCompletedAt,
+            projectEntries: entriesCompletedAt - provenanceCompletedAt,
+            validateEntries: validationCompletedAt - entriesCompletedAt,
+            sortEntries: completedAt - validationCompletedAt,
+            total: completedAt - startedAt,
+        }));
+    }
     return { snapshotSequence: BigInt(snapshotSequence).toString(10), entries };
 }
 export function buildWorkspaceSyncV3NestedRepairSnapshot(input) {

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

@@ -134,6 +134,7 @@ export type WorkspaceSyncV3TaskAttachmentLinksEnvelope = WorkspaceSyncV3Operatio
     baseLifecycleRevision: '0';
     payload: {
         links: WorkspaceSyncV3TaskAttachmentLink[];
+        cardCoverAssetId?: string | null;
         originActor?: WorkspaceSyncV3OriginActor;
     };
 }>;

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

@@ -0,0 +1,2 @@
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
+export declare function workspaceSyncV3RepairEntityReadBatchSize(db: DatabaseAdapter): number;

package/dist/sync/v3/workspaceSyncV3RepairSqlBatching.js

@@ -0,0 +1,10 @@
+const SQLITE_ENTITY_READ_BATCH_SIZE = 400;
+// These reads bind one parameter per entity plus a small fixed scope. Keeping
+// the batch at 4,000 remains far below PostgreSQL's 65,535 parameter limit
+// while avoiding dozens of synchronous database-worker round trips.
+const POSTGRES_ENTITY_READ_BATCH_SIZE = 4000;
+export function workspaceSyncV3RepairEntityReadBatchSize(db) {
+    return db.provider === 'postgres'
+        ? POSTGRES_ENTITY_READ_BATCH_SIZE
+        : SQLITE_ENTITY_READ_BATCH_SIZE;
+}

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

@@ -2,7 +2,7 @@ import { serializeTaskForSync, type TaskSyncPayload } from '../taskSyncPayload.j
 import type { TaxonomyTaskRemapAuthoritativePayload } from './taxonomyCompositeMutationService.js';
 import type { WorkspaceSyncJournalRow } from './workspaceSyncJournalReader.js';
 export type WorkspaceSyncV3TaskRootMutationKind = 'create' | 'metadata-update' | 'archive' | 'unarchive' | 'complete' | 'reopen' | 'set-status' | 'taxonomy-remap' | 'delete';
-export type WorkspaceSyncV3TaskRootPayload = Omit<TaskSyncPayload, 'attachments' | 'checklistItems' | 'comments'>;
+export type WorkspaceSyncV3TaskRootPayload = Omit<TaskSyncPayload, 'attachments' | 'cardCoverAssetId' | 'checklistItems' | 'comments'>;
 export type WorkspaceSyncV3TaskRootTombstone = {
     taskId: string;
     deletedAt: string;

package/dist/sync/v3/workspaceSyncV3TaskRootProjection.js

@@ -20,7 +20,7 @@ const FULL_MUTATIONS = new Set([
 ]);
 const TASK_STATUSES = new Set(['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']);
 function taskRootFromSerialized(task) {
-    const { attachments: _attachments, checklistItems: _checklistItems, comments: _comments, ...root } = task;
+    const { attachments: _attachments, cardCoverAssetId: _cardCoverAssetId, checklistItems: _checklistItems, comments: _comments, ...root } = task;
     return root;
 }
 export function serializeTaskRootForSync(task) {

package/dist/sync/workspacePullFeed.d.ts

@@ -1,6 +1,6 @@
 import type { TaskforceCore, TaskforceSyncCapable, TaskRelationshipRecord } from '../core/Taskforce.js';
 import type { WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
-import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAgentConversationSnapshot, WorkspaceSyncAgentRoleSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncChange, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncDurableTaskRevision, WorkspaceSyncDurablePlanningRevision, WorkspaceSyncDurableTaxonomyRevision, WorkspaceSyncEntityEventSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncTaskEventSnapshot, WorkspaceSyncTaskSnapshot, WorkspaceSyncTaskforceAgentSnapshot, WorkspaceSyncTaskforceAgentSkillSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
+import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAgentConversationSnapshot, WorkspaceSyncAgentRoleSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncChange, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncDurableTaskRevision, WorkspaceSyncDurablePlanningRevision, WorkspaceSyncDurableTaxonomyRevision, WorkspaceSyncEntityEventSnapshot, WorkspaceSyncInitiativeSnapshot, WorkspaceSyncPlanningIdentitySnapshot, WorkspaceSyncTaskEventSnapshot, WorkspaceSyncTaskSnapshot, WorkspaceSyncTaskforceAgentSnapshot, WorkspaceSyncTaskforceAgentSkillSnapshot, WorkspaceSyncWorkspaceMemberSnapshot, WorkspaceSyncWorkstreamSnapshot } from './workspaceSyncModel.js';
 import { createCollaborationSyncState } from './collaborationSyncState.js';
 import { createContentSyncState } from './contentSyncState.js';
 import type { WorkspaceAssetSyncLinkPayload } from './contentSyncPayload.js';
@@ -52,6 +52,11 @@ type PullFeedEntry = {
     watermark: string;
     sortId: string;
     workstream: WorkspaceSyncWorkstreamSnapshot;
+} | {
+    kind: 'planning-identity';
+    watermark: string;
+    sortId: string;
+    identity: WorkspaceSyncPlanningIdentitySnapshot;
 } | {
     kind: 'ai-profile';
     watermark: string;