@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/sync/v3/workspaceSyncV3CombinedRepairMaterialization.js

@@ -1,11 +1,12 @@
 import { createHmac, randomUUID, timingSafeEqual } from 'crypto';
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
 import { decodeCanonicalWorkspaceSyncBase64Url } from './workspaceSyncV3CursorEncoding.js';
-import { prepareWorkspaceSyncV3CombinedRepairSnapshot, prepareWorkspaceSyncV3NestedRepairSnapshot, prepareWorkspaceSyncV3PlanningOrderRepairSnapshot, prepareWorkspaceSyncV3WorkflowRepairSnapshot, } from './workspaceSyncV3CombinedRepairBaseline.js';
+import { prepareWorkspaceSyncV3CombinedRepairSnapshot, prepareWorkspaceSyncV3NestedRepairSnapshot, prepareWorkspaceSyncV3PlanningOrderRepairSnapshot, prepareWorkspaceSyncV3TaskCoverRepairSnapshot, prepareWorkspaceSyncV3WorkflowRepairSnapshot, } from './workspaceSyncV3CombinedRepairBaseline.js';
 import { validateWorkspaceSyncV3CombinedFeedEntry, WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE, } from './workspaceSyncV3CombinedCoverage.js';
 import { validateWorkspaceSyncV3NestedCoverageFeedEntry, WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE, } from './workspaceSyncV3NestedCoverage.js';
 import { validateWorkspaceSyncV3WorkflowCoverageFeedEntry, WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE, } from './workspaceSyncV3WorkflowCoverage.js';
 import { validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry, WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE, } from './workspaceSyncV3PlanningOrderCoverage.js';
+import { validateWorkspaceSyncV3TaskCoverCoverageFeedEntry, WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE, } from './workspaceSyncV3TaskCoverCoverage.js';
 import { createWorkspaceSyncV3FeedResumeCursor, WorkspaceSyncV3FeedOperationTooLargeError, } from './workspaceSyncV3Feed.js';
 import { findWorkspaceSyncV3FeedCursorVerificationKey, } from './workspaceSyncV3FeedCursorKeys.js';
 import { WORKSPACE_SYNC_COMBINED_PROJECTION, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
@@ -14,7 +15,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;
@@ -91,14 +96,19 @@ export function decodeWorkspaceSyncV3WorkflowRepairCursor(raw, keyring) {
 export function decodeWorkspaceSyncV3PlanningOrderRepairCursor(raw, keyring) {
     return decodeRepairCursor(raw, keyring, WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE);
 }
+export function decodeWorkspaceSyncV3TaskCoverRepairCursor(raw, keyring) {
+    return decodeRepairCursor(raw, keyring, WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE);
+}
 function repairProfile(coverage) {
     return coverage === 'workflow'
         ? WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE
-        : coverage === 'planning-order'
-            ? WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE
-            : coverage === 'nested'
-                ? WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE
-                : WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE;
+        : coverage === 'task-cover'
+            ? WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE
+            : coverage === 'planning-order'
+                ? WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE
+                : coverage === 'nested'
+                    ? WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE
+                    : WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE;
 }
 function containsCurrentEntityEventInventory(input) {
     if (input.coverage === 'combined')
@@ -136,27 +146,70 @@ function containsCurrentEntityEventInventory(input) {
                 AND entry.domain = 'entity-event'
                 AND entry.entity_id = event.id
           )
+          AND NOT EXISTS (
+              SELECT 1
+              FROM workspace_sync_journal journal
+              WHERE journal.tenant_id = event.tenant_id
+                AND journal.workspace_id = event.workspace_id
+                AND journal.domain = 'entity-event'
+                AND journal.entity_id = event.id
+                -- Later sequenced events are delivered after the immutable
+                -- repair boundary; only unsequenced legacy adoption makes the
+                -- snapshot incomplete and requires rematerialization.
+                AND journal.sequence > ?
+          )
         LIMIT 1
-    `).get(input.tenantId, input.workspaceId, input.snapshotId);
+    `).get(input.tenantId, input.workspaceId, input.snapshotId, input.snapshotSequence);
     return !missing;
 }
-function cleanupExpired(core, tenantId, workspaceId, now, excludingSnapshotId) {
+export const WORKSPACE_SYNC_REPAIR_SNAPSHOT_CLEANUP_BATCH_SIZE = 500;
+function cleanupExpiredBestEffort(core, tenantId, workspaceId, now, excludingSnapshotId) {
     const db = core.getDatabaseAdapter();
     const exclusion = excludingSnapshotId ? ' AND snapshot_id <> ?' : '';
     const args = excludingSnapshotId
         ? [tenantId, workspaceId, now, excludingSnapshotId]
         : [tenantId, workspaceId, now];
-    db.prepare(`
-        DELETE FROM workspace_sync_repair_snapshot_entries
-        WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id IN (
-            SELECT snapshot_id FROM workspace_sync_repair_snapshots
-            WHERE tenant_id = ? AND workspace_id = ? AND expires_at <= ?${exclusion}
-        )
-    `).run(tenantId, workspaceId, ...args);
-    db.prepare(`
-        DELETE FROM workspace_sync_repair_snapshots
-        WHERE tenant_id = ? AND workspace_id = ? AND expires_at <= ?${exclusion}
-    `).run(...args);
+    try {
+        db.transaction(() => {
+            const expired = db.prepare(`
+                SELECT snapshot_id
+                FROM workspace_sync_repair_snapshots
+                WHERE tenant_id = ? AND workspace_id = ? AND expires_at <= ?${exclusion}
+                ORDER BY expires_at ASC, snapshot_id ASC
+                LIMIT 1
+            `).get(...args);
+            const snapshotId = String(expired?.snapshot_id || '').trim();
+            if (!snapshotId)
+                return;
+            db.prepare(`
+                DELETE FROM workspace_sync_repair_snapshot_entries
+                WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ?
+                  AND entry_index IN (
+                      SELECT entry_index
+                      FROM workspace_sync_repair_snapshot_entries
+                      WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ?
+                      ORDER BY entry_index ASC
+                      LIMIT ?
+                  )
+            `).run(tenantId, workspaceId, snapshotId, tenantId, workspaceId, snapshotId, WORKSPACE_SYNC_REPAIR_SNAPSHOT_CLEANUP_BATCH_SIZE);
+            db.prepare(`
+                DELETE FROM workspace_sync_repair_snapshots
+                WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ? AND expires_at <= ?
+                  AND NOT EXISTS (
+                      SELECT 1 FROM workspace_sync_repair_snapshot_entries
+                      WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ?
+                  )
+            `).run(tenantId, workspaceId, snapshotId, now, tenantId, workspaceId, snapshotId);
+        })();
+    }
+    catch (error) {
+        // Expired snapshot removal is opportunistic maintenance. A cleanup
+        // timeout must not invalidate an otherwise valid repair response.
+        console.warn('[Taskforce Sync Repair Cleanup Deferred]', JSON.stringify({
+            workspaceId,
+            error: String(error?.message || error),
+        }));
+    }
 }
 function persistMaterialization(input) {
     const db = input.core.getDatabaseAdapter();
@@ -170,8 +223,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));
@@ -218,6 +274,7 @@ function readMetadata(input) {
             tenantId: input.tenantId,
             workspaceId: input.workspaceId,
             snapshotId: input.cursor.snapshotId,
+            snapshotSequence: input.cursor.snapshotSequence,
             coverage: input.coverage,
         })) {
         throw new WorkspaceSyncV3CombinedRepairSnapshotUnavailableError();
@@ -268,6 +325,7 @@ function readReusableMetadata(input) {
         tenantId: input.tenantId,
         workspaceId: input.workspaceId,
         snapshotId: String(row.snapshot_id),
+        snapshotSequence: sequence(row.snapshot_sequence, 'Combined repair snapshot sequence'),
         coverage: input.coverage,
     }))
         return null;
@@ -299,11 +357,13 @@ function mapEntry(row, coverage) {
     };
     (coverage === 'workflow'
         ? validateWorkspaceSyncV3WorkflowCoverageFeedEntry
-        : coverage === 'planning-order'
-            ? validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry
-            : coverage === 'nested'
-                ? validateWorkspaceSyncV3NestedCoverageFeedEntry
-                : validateWorkspaceSyncV3CombinedFeedEntry)(entry);
+        : coverage === 'task-cover'
+            ? validateWorkspaceSyncV3TaskCoverCoverageFeedEntry
+            : coverage === 'planning-order'
+                ? validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry
+                : coverage === 'nested'
+                    ? validateWorkspaceSyncV3NestedCoverageFeedEntry
+                    : validateWorkspaceSyncV3CombinedFeedEntry)(entry);
     return entry;
 }
 function finalizePage(input) {
@@ -362,22 +422,15 @@ export function buildWorkspaceSyncV3CombinedRepairPage(input) {
     const db = input.core.getDatabaseAdapter();
     const coverage = input.workflowCoverage
         ? 'workflow'
-        : input.planningOrderCoverage
-            ? 'planning-order'
-            : input.nestedCoverage
-                ? 'nested'
-                : 'combined';
+        : input.taskCoverCoverage
+            ? 'task-cover'
+            : input.planningOrderCoverage
+                ? 'planning-order'
+                : input.nestedCoverage
+                    ? 'nested'
+                    : 'combined';
     if (input.cursor && Date.parse(input.cursor.expiresAt) <= Date.parse(now)) {
-        db.transaction(() => {
-            db.prepare(`DELETE FROM workspace_sync_repair_snapshot_entries
-                WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ? AND EXISTS (
-                    SELECT 1 FROM workspace_sync_repair_snapshots
-                    WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ? AND expires_at <= ?
-                )`).run(tenantId, workspaceId, input.cursor.snapshotId, tenantId, workspaceId, input.cursor.snapshotId, now);
-            db.prepare(`DELETE FROM workspace_sync_repair_snapshots
-                WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ? AND expires_at <= ?`)
-                .run(tenantId, workspaceId, input.cursor.snapshotId, now);
-        })();
+        cleanupExpiredBestEffort(input.core, tenantId, workspaceId, now);
         throw new WorkspaceSyncV3CombinedRepairSnapshotUnavailableError();
     }
     let insertedBaselineEntities = 0;
@@ -386,17 +439,17 @@ export function buildWorkspaceSyncV3CombinedRepairPage(input) {
     let metadata;
     let nextIndex;
     if (input.cursor) {
+        cleanupExpiredBestEffort(input.core, tenantId, workspaceId, now, input.cursor.snapshotId);
         metadata = db.transaction(() => {
-            const current = readMetadata({
+            return readMetadata({
                 core: input.core, tenantId, workspaceId, cursor: input.cursor, now,
                 coverage,
             });
-            cleanupExpired(input.core, tenantId, workspaceId, now, current.snapshotId);
-            return current;
         })();
         nextIndex = input.cursor.nextIndex;
     }
     else {
+        cleanupExpiredBestEffort(input.core, tenantId, workspaceId, now);
         const materialized = db.transaction(() => {
             // Serialize cursorless materialization and reuse decisions with
             // durable writers and competing repair requests.
@@ -406,7 +459,6 @@ export function buildWorkspaceSyncV3CombinedRepairPage(input) {
                 ON CONFLICT (tenant_id, workspace_id) DO UPDATE SET updated_at = excluded.updated_at
                 RETURNING CAST(last_sequence AS TEXT) AS last_sequence
             `).get(tenantId, workspaceId, now);
-            cleanupExpired(input.core, tenantId, workspaceId, now);
             const reusable = readReusableMetadata({
                 core: input.core, tenantId, workspaceId, now,
                 coverage,
@@ -414,18 +466,27 @@ 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 })
-                    : coverage === 'nested'
-                        ? prepareWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId, now })
-                        : prepareWorkspaceSyncV3CombinedRepairSnapshot({ core: input.core, workspaceId, now });
+                    ? prepareWorkspaceSyncV3PlanningOrderRepairSnapshot({ core: input.core, workspaceId, now,
+                        coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
+                    : coverage === 'task-cover'
+                        ? prepareWorkspaceSyncV3TaskCoverRepairSnapshot({ core: input.core, workspaceId, now,
+                            coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
+                        : coverage === 'nested'
+                            ? prepareWorkspaceSyncV3NestedRepairSnapshot({ core: input.core, workspaceId, now,
+                                coveredLegacyWritesFenced: input.coveredLegacyWritesFenced })
+                            : prepareWorkspaceSyncV3CombinedRepairSnapshot({ core: input.core, workspaceId, now,
+                                coveredLegacyWritesFenced: input.coveredLegacyWritesFenced });
             // Production expiry is sampled at the end of persistence, after
             // every immutable payload row has committed in the same lock.
             const materializationStartedAt = input.now
                 ? 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 +495,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 };
@@ -503,3 +573,6 @@ export function buildWorkspaceSyncV3WorkflowRepairPage(input) {
 export function buildWorkspaceSyncV3PlanningOrderRepairPage(input) {
     return buildWorkspaceSyncV3CombinedRepairPage({ ...input, planningOrderCoverage: true });
 }
+export function buildWorkspaceSyncV3TaskCoverRepairPage(input) {
+    return buildWorkspaceSyncV3CombinedRepairPage({ ...input, taskCoverCoverage: true });
+}

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

@@ -31,6 +31,8 @@ export declare class WorkspaceSyncV3CombinedRepairBaselineRequiredError extends
 export declare function listWorkspaceSyncV3CombinedRepairCandidates(core: TaskforceCore, workspaceId: string): WorkspaceSyncV3CombinedRepairCandidate[];
 /** Candidate v4 inventory. The coverage-v3 inventory above intentionally remains unchanged. */
 export declare function listWorkspaceSyncV3NestedRepairCandidates(core: TaskforceCore, workspaceId: string): WorkspaceSyncV3CombinedRepairCandidate[];
+/** Candidate v7 inventory. It is the v4 family with attachment-link schema v2. */
+export declare function listWorkspaceSyncV3TaskCoverRepairCandidates(core: TaskforceCore, workspaceId: string): WorkspaceSyncV3CombinedRepairCandidate[];
 /** Candidate v5 inventory. Coverage-v3/v4 inventories intentionally remain unchanged. */
 export declare function listWorkspaceSyncV3WorkflowRepairCandidates(core: TaskforceCore, workspaceId: string): WorkspaceSyncV3CombinedRepairCandidate[];
 /** Candidate v6 inventory. Workflow v5 remains an independent dark contract. */
@@ -50,6 +52,7 @@ export declare function buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCand
     nestedCoverage?: boolean;
     workflowCoverage?: boolean;
     planningOrderCoverage?: boolean;
+    taskCoverCoverage?: boolean;
 }): {
     snapshotSequence: string;
     entries: WorkspaceSyncV3FeedEntry[];
@@ -75,4 +78,11 @@ export declare function buildWorkspaceSyncV3PlanningOrderRepairSnapshot(input: {
     snapshotSequence: string;
     entries: WorkspaceSyncV3FeedEntry[];
 };
+export declare function buildWorkspaceSyncV3TaskCoverRepairSnapshot(input: {
+    core: TaskforceCore;
+    workspaceId: string;
+}): {
+    snapshotSequence: string;
+    entries: WorkspaceSyncV3FeedEntry[];
+};
 export {};

package/dist/sync/v3/workspaceSyncV3CombinedRepairSnapshot.js

@@ -8,18 +8,19 @@ import { serializeTaskRootForSync, projectWorkspaceSyncV3TaskRootJournalRow } fr
 import { projectWorkspaceSyncV3TaxonomyJournalRow } from './workspaceSyncV3TaxonomyFeedProjection.js';
 import { projectWorkspaceSyncV3WorkstreamJournalRow } from './workspaceSyncV3WorkstreamProjection.js';
 import { buildWorkspaceSyncV3NestedTaskRepairCandidates, } from './workspaceSyncV3NestedTaskRepairSnapshot.js';
-import { projectWorkspaceSyncV3NestedTaskJournalRow } from './workspaceSyncV3NestedTaskProjection.js';
+import { projectWorkspaceSyncV3NestedTaskJournalRow, projectWorkspaceSyncV3NestedTaskV2JournalRow, } from './workspaceSyncV3NestedTaskProjection.js';
 import { validateWorkspaceSyncV3NestedCoverageFeedEntry, WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE, } from './workspaceSyncV3NestedCoverage.js';
 import { serializeWorkflowExecutionEventSyncPayload, serializeWorkflowExecutionRootSyncPayload, serializeWorkflowPublishedDefinitionSyncPayload, } from './workflowRuntimeSync.js';
 import { projectWorkspaceSyncV3WorkflowRuntimeJournalRow, } from './workspaceSyncV3WorkflowRuntimeProjection.js';
 import { validateWorkspaceSyncV3WorkflowCoverageFeedEntry, WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE, } from './workspaceSyncV3WorkflowCoverage.js';
 import { validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry, WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE, } from './workspaceSyncV3PlanningOrderCoverage.js';
+import { validateWorkspaceSyncV3TaskCoverCoverageFeedEntry, WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE, } from './workspaceSyncV3TaskCoverCoverage.js';
 import { projectWorkspaceSyncV3WorkstreamTaskOrderJournalRow } from './workspaceSyncV3WorkstreamTaskOrderProjection.js';
 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
@@ -28,6 +29,8 @@ const WORKFLOW_PROJECTION_RANK = new Map(WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PRO
     .map((projection, index) => [projection.projectionId, index]));
 const PLANNING_ORDER_PROJECTION_RANK = new Map(WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_PROFILE.projections
     .map((projection, index) => [projection.projectionId, index]));
+const TASK_COVER_PROJECTION_RANK = new Map(WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE.projections
+    .map((projection, index) => [projection.projectionId, index]));
 export class WorkspaceSyncV3CombinedRepairBaselineRequiredError extends Error {
     missing;
     code = 'WORKSPACE_SYNC_V3_COMBINED_REPAIR_BASELINE_REQUIRED';
@@ -42,17 +45,22 @@ function compareCodeUnits(left, right) {
 function projectionRank(entry, coverage) {
     const ranks = coverage === 'workflow'
         ? WORKFLOW_PROJECTION_RANK
-        : coverage === 'planning-order'
-            ? PLANNING_ORDER_PROJECTION_RANK
-            : coverage === 'nested'
-                ? NESTED_PROJECTION_RANK
-                : COMBINED_PROJECTION_RANK;
+        : coverage === 'task-cover'
+            ? TASK_COVER_PROJECTION_RANK
+            : coverage === 'planning-order'
+                ? PLANNING_ORDER_PROJECTION_RANK
+                : coverage === 'nested'
+                    ? NESTED_PROJECTION_RANK
+                    : COMBINED_PROJECTION_RANK;
     const rank = ranks.get(entry.projection);
     if (rank === undefined)
         throw new Error(`Unsupported combined repair projection: ${entry.projection}.`);
     return rank;
 }
 function listTasks(core, workspaceId) {
+    if (typeof core.listTasksForAuthoritativeRepair === 'function') {
+        return core.listTasksForAuthoritativeRepair(workspaceId);
+    }
     const result = [];
     let cursor = null;
     for (;;) {
@@ -148,20 +156,28 @@ function listLiveEvents(core, workspaceId, liveEntityIds) {
         cursor = { watermark: last.createdAt, id: eventCursorId(last) };
     }
 }
-/** Candidate v4 inventory. The coverage-v3 inventory above intentionally remains unchanged. */
-export function listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId) {
+function listNestedRepairCandidates(core, workspaceId, attachmentProjection) {
+    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 +187,41 @@ export function listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId) {
         ...workstreams,
         ...buildWorkspaceSyncV3NestedTaskRepairCandidates({
             tasks,
-            events: listLiveEvents(core, workspaceId, liveEntityIds),
+            events,
             attachmentLinksByTaskId,
+            attachmentProjection,
         }),
     ];
+    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 v4 inventory. The coverage-v3 inventory above intentionally remains unchanged. */
+export function listWorkspaceSyncV3NestedRepairCandidates(core, workspaceId) {
+    return listNestedRepairCandidates(core, workspaceId, 'task-attachment-links/full-v1');
+}
+/** Candidate v7 inventory. It is the v4 family with attachment-link schema v2. */
+export function listWorkspaceSyncV3TaskCoverRepairCandidates(core, workspaceId) {
+    return listNestedRepairCandidates(core, workspaceId, 'task-attachment-links/full-v2');
 }
 /** Candidate v5 inventory. Coverage-v3/v4 inventories intentionally remain unchanged. */
 export function listWorkspaceSyncV3WorkflowRepairCandidates(core, workspaceId) {
@@ -258,10 +305,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 +332,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.*
@@ -344,7 +393,7 @@ function taskEntry(candidate, row, priorFullRow) {
     return { ...projected, mutationKind, payload: candidate.payload,
         payloadFingerprint: fingerprintWorkspaceSyncPayload(candidate.payload) };
 }
-function entry(candidate, row, taskFullProvenance) {
+function entry(candidate, row, taskFullProvenance, taskCoverCoverage = false) {
     if (candidate.domain === 'workstream-task-order') {
         const projected = projectWorkspaceSyncV3WorkstreamTaskOrderJournalRow(row);
         if (!projected
@@ -365,7 +414,9 @@ function entry(candidate, row, taskFullProvenance) {
     }
     if (candidate.domain === 'task-comments' || candidate.domain === 'task-checklist'
         || candidate.domain === 'task-attachment-links' || candidate.domain === 'entity-event') {
-        const projected = projectWorkspaceSyncV3NestedTaskJournalRow(row);
+        const projected = taskCoverCoverage && candidate.domain === 'task-attachment-links'
+            ? projectWorkspaceSyncV3NestedTaskV2JournalRow(row)
+            : projectWorkspaceSyncV3NestedTaskJournalRow(row);
         if (!projected) {
             throw new Error(`${candidate.domain} repair revision does not match canonical state: ${candidate.entityId}.`);
         }
@@ -427,7 +478,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,27 +489,48 @@ 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 entries = inventory.map((candidate) => entry(candidate, rows.get(`${candidate.domain}\0${candidate.entityId}`), taskFullProvenance));
+    const provenanceCompletedAt = Date.now();
+    const entries = inventory.map((candidate) => entry(candidate, rows.get(`${candidate.domain}\0${candidate.entityId}`), taskFullProvenance, input.taskCoverCoverage === true));
+    const entriesCompletedAt = Date.now();
     const coverage = input.workflowCoverage
         ? 'workflow'
-        : input.planningOrderCoverage
-            ? 'planning-order'
-            : input.nestedCoverage
-                ? 'nested'
-                : 'combined';
+        : input.taskCoverCoverage
+            ? 'task-cover'
+            : input.planningOrderCoverage
+                ? 'planning-order'
+                : input.nestedCoverage
+                    ? 'nested'
+                    : 'combined';
     entries.forEach(coverage === 'workflow'
         ? validateWorkspaceSyncV3WorkflowCoverageFeedEntry
-        : coverage === 'planning-order'
-            ? validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry
-            : coverage === 'nested'
-                ? validateWorkspaceSyncV3NestedCoverageFeedEntry
-                : validateWorkspaceSyncV3CombinedFeedEntry);
+        : coverage === 'task-cover'
+            ? validateWorkspaceSyncV3TaskCoverCoverageFeedEntry
+            : coverage === 'planning-order'
+                ? validateWorkspaceSyncV3PlanningOrderCoverageFeedEntry
+                : coverage === 'nested'
+                    ? validateWorkspaceSyncV3NestedCoverageFeedEntry
+                    : validateWorkspaceSyncV3CombinedFeedEntry);
+    const validationCompletedAt = Date.now();
     if (entries.some((candidate) => BigInt(candidate.sequence) > BigInt(snapshotSequence))) {
         throw new Error('Combined repair entry exceeds the locked snapshot sequence.');
     }
     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) {
@@ -509,3 +583,21 @@ export function buildWorkspaceSyncV3PlanningOrderRepairSnapshot(input) {
         });
     })();
 }
+export function buildWorkspaceSyncV3TaskCoverRepairSnapshot(input) {
+    const workspaceId = String(input.workspaceId || '').trim();
+    if (!workspaceId)
+        throw new Error('Workspace id is required.');
+    const tenantId = input.core.getTenantId();
+    const db = input.core.getDatabaseAdapter();
+    return db.transaction(() => {
+        const snapshotSequence = lockAndReadHighWatermark(db, tenantId, workspaceId);
+        const inventory = listWorkspaceSyncV3TaskCoverRepairCandidates(input.core, workspaceId);
+        return buildWorkspaceSyncV3CombinedRepairSnapshotFromLockedCandidates({
+            core: input.core,
+            workspaceId,
+            snapshotSequence,
+            inventory,
+            taskCoverCoverage: true,
+        });
+    })();
+}

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

@@ -2,6 +2,7 @@ import type { WorkspaceSyncV2ProjectionExclusion } from './workspaceSyncV2Projec
 import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR } from './workspaceSyncV3NestedWireContract.js';
 import { WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR } from './workspaceSyncV3WorkflowWireContract.js';
 import { WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR } from './workspaceSyncV3PlanningOrderWireContract.js';
+import { WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR } from './workspaceSyncV3TaskCoverWireContract.js';
 export declare const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR: Readonly<{
     coverageProfileId: "task-planning-metadata";
     coverageVersion: 3;
@@ -9,13 +10,14 @@ export declare const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR: Readonly<{
 }>;
 export declare const WORKSPACE_SYNC_V3_COMBINED_CAPABILITY_VERSION: 1;
 export declare const WORKSPACE_SYNC_V3_COMBINED_EXCLUDED_V2_PROJECTIONS: readonly ["task/root-v1", "task-relationship/full-v1", "taxonomy/full-v1", "initiative/full-v1", "workstream/full-v1"];
-export type WorkspaceSyncV3CombinedCoverageSelector = typeof WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR;
+export type WorkspaceSyncV3CombinedCoverageSelector = typeof WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_PLANNING_ORDER_COVERAGE_SELECTOR | typeof WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR;
 export interface WorkspaceSyncV3CombinedWireContract {
     coverage: WorkspaceSyncV3CombinedCoverageSelector;
     excludedProjections: readonly WorkspaceSyncV2ProjectionExclusion[];
     nestedWriterPrerequisitesRequired: boolean;
     workflowWriterPrerequisitesRequired: boolean;
     planningOrderWriterPrerequisitesRequired: boolean;
+    taskCoverProjectionRequired: boolean;
 }
 export declare function resolveWorkspaceSyncV3CombinedWireContract(input: {
     coverageProfileId: unknown;