@taskforcehq/taskforce 0.3.328 → 0.3.329

package/dist/sync/v3/workspaceSyncV3NestedTaskProjection.js

@@ -4,7 +4,7 @@ import { assertWorkspaceSyncV3OperationBoundary } from './workspaceSyncV3Operati
 import { projectWorkspaceSyncV3TaskRootJournalRow } from './workspaceSyncV3TaskRootProjection.js';
 import { projectWorkspaceSyncV3InitiativeJournalRow } from './workspaceSyncV3Feed.js';
 import { projectWorkspaceSyncV3WorkstreamJournalRow } from './workspaceSyncV3WorkstreamProjection.js';
-import { serializeWorkspaceSyncV3EntityEventPayload, validateWorkspaceSyncV3EntityEventPayload, validateWorkspaceSyncV3TaskAttachmentLinksPayload, validateWorkspaceSyncV3TaskChecklistPayload, validateWorkspaceSyncV3TaskCommentAppendPayload, validateWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+import { serializeWorkspaceSyncV3EntityEventPayload, serializeWorkspaceSyncV3TaskAttachmentLinksPayload, validateWorkspaceSyncV3EntityEventPayload, validateWorkspaceSyncV3TaskAttachmentLinksPayload, validateWorkspaceSyncV3TaskAttachmentLinksV2Payload, validateWorkspaceSyncV3TaskChecklistPayload, validateWorkspaceSyncV3TaskCommentAppendPayload, validateWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
 import { isLegacyEntityEventAdoptionIdentity } from './entityEventLegacyAdoptionContract.js';
 export const WORKSPACE_SYNC_V3_NESTED_TASK_PROJECTIONS = Object.freeze([
     Object.freeze({
@@ -46,6 +46,15 @@ export const WORKSPACE_SYNC_V3_NESTED_TASK_PROJECTIONS = Object.freeze([
         operationAtomic: true,
     }),
 ]);
+export const WORKSPACE_SYNC_V3_TASK_ATTACHMENT_LINKS_V2_PROJECTION = Object.freeze({
+    projectionId: 'task-attachment-links/full-v2',
+    domain: 'task-attachment-links',
+    schemaVersion: 2,
+    mutationKinds: Object.freeze(['replace']),
+    fields: Object.freeze(['taskId', 'links', 'cardCoverAssetId']),
+    dependencies: Object.freeze(['task/root-v1']),
+    operationAtomic: true,
+});
 const projectionByDomain = new Map(WORKSPACE_SYNC_V3_NESTED_TASK_PROJECTIONS.map((projection) => [projection.domain, projection.projectionId]));
 function sequence(value, label) {
     const text = String(value ?? '').trim();
@@ -68,7 +77,7 @@ function parsePayload(row) {
         throw new Error(`Nested task journal payload is malformed at ${row.sequence}.`);
     }
 }
-function canonicalPayload(row) {
+function canonicalPayload(row, attachmentProjection) {
     const raw = parsePayload(row);
     if (row.domain === 'task-comments') {
         if (row.mutationKind === 'append') {
@@ -91,7 +100,17 @@ function canonicalPayload(row) {
         return { payload, canonicalFingerprint: fingerprintWorkspaceSyncPayload(payload) };
     }
     if (row.domain === 'task-attachment-links' && row.mutationKind === 'replace') {
-        const payload = validateWorkspaceSyncV3TaskAttachmentLinksPayload(raw);
+        const payload = attachmentProjection === 'task-attachment-links/full-v2'
+            ? validateWorkspaceSyncV3TaskAttachmentLinksV2Payload(raw)
+            : (() => {
+                try {
+                    return validateWorkspaceSyncV3TaskAttachmentLinksPayload(raw);
+                }
+                catch {
+                    const v2 = validateWorkspaceSyncV3TaskAttachmentLinksV2Payload(raw);
+                    return serializeWorkspaceSyncV3TaskAttachmentLinksPayload(v2);
+                }
+            })();
         if (payload.taskId !== row.entityId)
             throw new Error(`Task attachment-link identity is invalid at ${row.sequence}.`);
         return { payload, canonicalFingerprint: fingerprintWorkspaceSyncPayload(payload) };
@@ -107,8 +126,10 @@ function canonicalPayload(row) {
 function canonicalEntityEventPayload(raw) {
     return validateWorkspaceSyncV3EntityEventPayload(serializeWorkspaceSyncV3EntityEventPayload(raw));
 }
-export function projectWorkspaceSyncV3NestedTaskJournalRow(row) {
-    const projection = projectionByDomain.get(row.domain);
+function projectNestedTaskJournalRow(row, attachmentProjection) {
+    const projection = row.domain === 'task-attachment-links'
+        ? attachmentProjection
+        : projectionByDomain.get(row.domain);
     if (!projection)
         return null;
     if (row.contractVersion !== WORKSPACE_SYNC_CONTRACT_VERSION) {
@@ -131,7 +152,7 @@ export function projectWorkspaceSyncV3NestedTaskJournalRow(row) {
         if (payload.action === 'sync-v3-repair-baseline')
             return null;
     }
-    const { payload, canonicalFingerprint } = canonicalPayload(row);
+    const { payload, canonicalFingerprint } = canonicalPayload(row, attachmentProjection);
     return {
         sequence: journalSequence,
         projection,
@@ -146,8 +167,17 @@ export function projectWorkspaceSyncV3NestedTaskJournalRow(row) {
         occurredAt,
     };
 }
+export function projectWorkspaceSyncV3NestedTaskJournalRow(row) {
+    return projectNestedTaskJournalRow(row, 'task-attachment-links/full-v1');
+}
+export function projectWorkspaceSyncV3NestedTaskV2JournalRow(row) {
+    return projectNestedTaskJournalRow(row, 'task-attachment-links/full-v2');
+}
 export function validateWorkspaceSyncV3NestedTaskFeedEntry(entry) {
-    const projected = projectWorkspaceSyncV3NestedTaskJournalRow({
+    const projector = entry.projection === 'task-attachment-links/full-v2'
+        ? projectWorkspaceSyncV3NestedTaskV2JournalRow
+        : projectWorkspaceSyncV3NestedTaskJournalRow;
+    const projected = projector({
         sequence: entry.sequence,
         contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
         clientId: 'validation-client',
@@ -181,9 +211,9 @@ function assertNestedDependentOrder(rows) {
         throw new Error('Nested task operation dependents are duplicated or out of order.');
     }
 }
-function projectNestedDependentRows(rows) {
+function projectNestedDependentRows(rows, attachmentProjection) {
     return rows.flatMap((row) => {
-        const projected = projectWorkspaceSyncV3NestedTaskJournalRow(row);
+        const projected = projectNestedTaskJournalRow(row, attachmentProjection);
         if (!projected) {
             const payload = row.domain === 'entity-event'
                 ? canonicalEntityEventPayload(parsePayload(row))
@@ -217,7 +247,7 @@ function isSupportedNestedOnlyOperation(rows) {
  * root. Apply still requires referenced parents to exist on the receiver; feed
  * only needs to project the nested rows.
  */
-function projectNestedOnlyOperation(rows) {
+function projectNestedOnlyOperation(rows, attachmentProjection) {
     if (!isSupportedNestedOnlyOperation(rows)) {
         throw new Error('Nested-only task operation is not an allowed repair or reconciliation shape.');
     }
@@ -229,7 +259,7 @@ function projectNestedOnlyOperation(rows) {
             throw new Error('Nested task operation dependent identity does not match its task root.');
         }
     }
-    const projected = projectNestedDependentRows(rows);
+    const projected = projectNestedDependentRows(rows, attachmentProjection);
     const events = projected
         .filter((entry) => entry.domain === 'entity-event')
         .map((entry) => validateWorkspaceSyncV3EntityEventPayload(entry.payload));
@@ -256,14 +286,14 @@ function projectNestedOnlyOperation(rows) {
  * parent-first operations; repair baselines and comment reconcile may emit
  * nested-only groups that still project when every row is a nested domain.
  */
-export function projectWorkspaceSyncV3NestedTaskOperation(input) {
+function projectNestedTaskOperation(input, attachmentProjection) {
     if (!input.rows.some((row) => projectionByDomain.has(row.domain)))
         return null;
     assertWorkspaceSyncV3OperationBoundary(input);
     const [first, ...dependents] = input.rows;
     if (first && projectionByDomain.has(first.domain)
         && input.rows.every((row) => projectionByDomain.has(row.domain))) {
-        return projectNestedOnlyOperation(input.rows);
+        return projectNestedOnlyOperation(input.rows, attachmentProjection);
     }
     if (!first || !['task', 'initiative', 'workstream'].includes(first.domain)) {
         throw new Error('Nested task operation must begin with its v3-owned parent root.');
@@ -272,7 +302,7 @@ export function projectWorkspaceSyncV3NestedTaskOperation(input) {
         throw new Error('Nested task operation contains an unsupported dependent row.');
     }
     assertNestedDependentOrder(dependents);
-    const projectedDependents = projectNestedDependentRows(dependents);
+    const projectedDependents = projectNestedDependentRows(dependents, attachmentProjection);
     const eventRows = projectedDependents.filter((entry) => entry.domain === 'entity-event');
     const rawEventRows = dependents.filter((row) => row.domain === 'entity-event');
     const sentinelOnly = eventRows.length === 0 && rawEventRows.length > 0 && rawEventRows.every((row) => (canonicalEntityEventPayload(parsePayload(row)).action === 'sync-v3-repair-baseline'));
@@ -327,3 +357,9 @@ export function projectWorkspaceSyncV3NestedTaskOperation(input) {
     }
     return [parent, ...projectedDependents];
 }
+export function projectWorkspaceSyncV3NestedTaskOperation(input) {
+    return projectNestedTaskOperation(input, 'task-attachment-links/full-v1');
+}
+export function projectWorkspaceSyncV3NestedTaskV2Operation(input) {
+    return projectNestedTaskOperation(input, 'task-attachment-links/full-v2');
+}

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

@@ -2,7 +2,7 @@ import type { EntityEvent, TaskItem } from '../../types.js';
 import type { WorkspaceSyncV3ProjectionDescriptor } from './workspaceSyncV3FeedProfile.js';
 import { type WorkspaceSyncV3TaskAttachmentLink } from './workspaceSyncV3NestedTaskCodecs.js';
 export type WorkspaceSyncV3NestedTaskRepairCandidate = {
-    projection: Extract<WorkspaceSyncV3ProjectionDescriptor, 'task-comments/full-v1' | 'task-checklist/full-v1' | 'task-attachment-links/full-v1' | 'entity-event/full-v1'>;
+    projection: Extract<WorkspaceSyncV3ProjectionDescriptor, 'task-comments/full-v1' | 'task-checklist/full-v1' | 'task-attachment-links/full-v1' | 'task-attachment-links/full-v2' | 'entity-event/full-v1'>;
     domain: 'task-comments' | 'task-checklist' | 'task-attachment-links' | 'entity-event';
     entityId: string;
     mutationKind: 'replace' | 'append';
@@ -16,4 +16,5 @@ export declare function buildWorkspaceSyncV3NestedTaskRepairCandidates(input: {
     tasks: readonly TaskItem[];
     events: readonly EntityEvent[];
     attachmentLinksByTaskId?: ReadonlyMap<string, readonly WorkspaceSyncV3TaskAttachmentLink[]>;
+    attachmentProjection?: 'task-attachment-links/full-v1' | 'task-attachment-links/full-v2';
 }): WorkspaceSyncV3NestedTaskRepairCandidate[];

package/dist/sync/v3/workspaceSyncV3NestedTaskRepairSnapshot.js

@@ -1,8 +1,9 @@
-import { serializeWorkspaceSyncV3EntityEventPayload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, validateWorkspaceSyncV3TaskAttachmentLinksPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+import { serializeWorkspaceSyncV3EntityEventPayload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, validateWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskAttachmentLinksV2Payload, } from './workspaceSyncV3NestedTaskCodecs.js';
 const rank = new Map([
     ['task-comments/full-v1', 0],
     ['task-checklist/full-v1', 1],
     ['task-attachment-links/full-v1', 2],
+    ['task-attachment-links/full-v2', 2],
     ['entity-event/full-v1', 3],
 ]);
 function compareCodeUnits(left, right) {
@@ -19,6 +20,7 @@ export function buildWorkspaceSyncV3NestedTaskRepairCandidates(input) {
         if (!links) {
             throw new Error(`Task attachment-link repair source is missing for ${task.id}.`);
         }
+        const attachmentProjection = input.attachmentProjection || 'task-attachment-links/full-v1';
         candidates.push({
             projection: 'task-comments/full-v1', domain: 'task-comments', entityId: task.id, mutationKind: 'replace',
             payload: serializeWorkspaceSyncV3TaskCommentsPayload({ taskId: task.id, comments: task.comments || [] }),
@@ -26,8 +28,14 @@ export function buildWorkspaceSyncV3NestedTaskRepairCandidates(input) {
             projection: 'task-checklist/full-v1', domain: 'task-checklist', entityId: task.id, mutationKind: 'replace',
             payload: serializeWorkspaceSyncV3TaskChecklistPayload({ taskId: task.id, items: task.checklistItems || [] }),
         }, {
-            projection: 'task-attachment-links/full-v1', domain: 'task-attachment-links', entityId: task.id, mutationKind: 'replace',
-            payload: validateWorkspaceSyncV3TaskAttachmentLinksPayload({ taskId: task.id, links: links || [] }),
+            projection: attachmentProjection, domain: 'task-attachment-links', entityId: task.id, mutationKind: 'replace',
+            payload: attachmentProjection === 'task-attachment-links/full-v2'
+                ? serializeWorkspaceSyncV3TaskAttachmentLinksV2Payload({
+                    taskId: task.id,
+                    links,
+                    cardCoverAssetId: task.cardCoverAssetId ?? null,
+                })
+                : validateWorkspaceSyncV3TaskAttachmentLinksPayload({ taskId: task.id, links }),
         });
     }
     for (const event of input.events) {

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

@@ -30,6 +30,7 @@ type TaskOperationBase<TMutationKind extends string, TPayload> = {
 export type WorkspaceSyncV3TaskMetadataEnvelope = WorkspaceSyncV3OperationEnvelopeBase<TaskOperationBase<'metadata-update', {
     patch: Partial<TaskItem>;
     saveSource?: 'manual' | 'autosave';
+    expectedDetailRevision?: string;
     originActor?: WorkspaceSyncV3OriginActor;
 }>>;
 export type WorkspaceSyncV3TaskCreateEnvelope = WorkspaceSyncV3OperationEnvelopeBase<TaskOperationBase<'create', {
@@ -74,6 +75,7 @@ export type WorkspaceSyncV3TaskWorkflowEnvelope = WorkspaceSyncV3OperationEnvelo
 export type WorkspaceSyncV3TaskStatusEnvelope = WorkspaceSyncV3OperationEnvelopeBase<TaskOperationBase<'set-status', DurableTaskStatusMutationPayload & {
     workflowAssignment?: WorkflowAssignmentSyncRecord;
     originActor?: WorkspaceSyncV3OriginActor;
+    expectedDetailRevision?: string;
 }>>;
 export type WorkspaceSyncV3WorkflowRuntimeEnvelope = WorkspaceSyncV3OperationEnvelopeBase<{
     domain: 'workflow-execution';

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

@@ -131,11 +131,13 @@ export interface WorkspaceSyncV3OperatorDiagnosticsSnapshot {
         };
         attachmentApply: {
             openObligations: number;
+            terminalObligations: number;
             dueObligations: number;
             oldestOpenCreatedAt: string | null;
             nextAttemptAt: string | null;
             attempted: number;
             lastError: string | null;
+            terminalReason: string | null;
         };
         runner: {
             available: boolean;

package/dist/sync/v3/workspaceSyncV3OperatorDiagnostics.js

@@ -216,12 +216,14 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
             WHERE tenant_id = ? AND workspace_id = ? AND resolved_at IS NULL
         `).get(tenantId, workspaceId);
         attachmentApplyRow = input.db.prepare(`
-            SELECT COUNT(*) AS count,
-                   SUM(CASE WHEN next_attempt_at <= ? THEN 1 ELSE 0 END) AS due,
-                   MIN(created_at) AS oldest_created_at,
-                   MIN(next_attempt_at) AS next_attempt_at,
-                   COALESCE(SUM(attempts), 0) AS attempts,
-                   MAX(last_error) AS last_error
+            SELECT SUM(CASE WHEN terminal_at IS NULL THEN 1 ELSE 0 END) AS count,
+                   SUM(CASE WHEN terminal_at IS NOT NULL THEN 1 ELSE 0 END) AS terminal,
+                   SUM(CASE WHEN terminal_at IS NULL AND next_attempt_at <= ? THEN 1 ELSE 0 END) AS due,
+                   MIN(CASE WHEN terminal_at IS NULL THEN created_at END) AS oldest_created_at,
+                   MIN(CASE WHEN terminal_at IS NULL THEN next_attempt_at END) AS next_attempt_at,
+                   COALESCE(SUM(CASE WHEN terminal_at IS NULL THEN attempts ELSE 0 END), 0) AS attempts,
+                   MAX(CASE WHEN terminal_at IS NULL THEN last_error END) AS last_error,
+                   MAX(CASE WHEN terminal_at IS NOT NULL THEN terminal_reason END) AS terminal_reason
             FROM workspace_sync_v3_attachment_apply_obligations
             WHERE tenant_id = ? AND workspace_id = ? AND resolved_at IS NULL
         `).get(nowIso, tenantId, workspaceId);
@@ -255,7 +257,9 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
     const oldestOpenRecoveryAt = String(recoveryRow?.oldest_created_at || '').trim() || null;
     const coordinatorGeneration = coordinatorState ? integer(coordinatorState.coordinator_generation) : null;
     const ownershipMode = coordinatorState ? String(coordinatorState.ownership_mode || '') || null : null;
-    const localConverged = baseLocalConverged && integer(attachmentApplyRow?.count) === 0;
+    const localConverged = baseLocalConverged
+        && integer(attachmentApplyRow?.count) === 0
+        && integer(attachmentApplyRow?.terminal) === 0;
     const coordinatorFailures = [];
     if (input.runtimeMode === 'local') {
         if (!coordinatorState)
@@ -279,6 +283,9 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
         if (integer(attachmentApplyRow?.count) > 0) {
             coordinatorFailures.push('open attachment apply obligations remain');
         }
+        if (integer(attachmentApplyRow?.terminal) > 0) {
+            coordinatorFailures.push('terminal unavailable attachment apply obligations require operator action');
+        }
         if (ownershipMode === 'server' && !runnerState) {
             coordinatorFailures.push('server ownership has no durable runner checkpoint');
         }
@@ -305,6 +312,9 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
             failures.push('recent pull/apply window contains 409 responses');
         if (integer(attachmentApplyRow?.count) > 0)
             failures.push('attachment apply obligations remain open');
+        if (integer(attachmentApplyRow?.terminal) > 0) {
+            failures.push('terminal unavailable attachment apply obligations require operator action');
+        }
         if (cursorAtCycleHighWatermark === null)
             unknowns.push('no committed feed cycle coordinates are available');
         if (!events.length)
@@ -387,11 +397,13 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
             },
             attachmentApply: {
                 openObligations: integer(attachmentApplyRow?.count),
+                terminalObligations: integer(attachmentApplyRow?.terminal),
                 dueObligations: integer(attachmentApplyRow?.due),
                 oldestOpenCreatedAt: String(attachmentApplyRow?.oldest_created_at || '').trim() || null,
                 nextAttemptAt: String(attachmentApplyRow?.next_attempt_at || '').trim() || null,
                 attempted: integer(attachmentApplyRow?.attempts),
                 lastError: String(attachmentApplyRow?.last_error || '').trim() || null,
+                terminalReason: String(attachmentApplyRow?.terminal_reason || '').trim() || null,
             },
             runner: {
                 available: Boolean(runnerState),

package/dist/sync/v3/workspaceSyncV3TaskCommentAudit.js

@@ -36,12 +36,19 @@ export function buildWorkspaceSyncV3TaskCommentAuditPage(input) {
     const workspaceId = String(input.workspaceId || '').trim();
     const previousCursor = normalizeCursor(input.cursor);
     const limit = pageSize(input.limit);
+    // Task IDs are compared in JavaScript when a page is installed locally.
+    // Make the database boundary use the same bytewise ordering so Postgres
+    // locale collation cannot place mixed-case IDs in an order the local
+    // validator rejects (SQLite already defaults to binary ordering here).
+    const taskIdWithCollationSql = input.core.getDatabaseAdapter().provider === 'postgres'
+        ? 'id COLLATE "C"'
+        : 'id COLLATE BINARY';
     const rows = input.core.getDatabaseAdapter().prepare(`
         SELECT id
         FROM tasks
         WHERE tenant_id = ? AND workspace_id = ?
-          AND (? = '' OR id > ?)
-        ORDER BY id
+          AND (? = '' OR ${taskIdWithCollationSql} > ?)
+        ORDER BY ${taskIdWithCollationSql}
         LIMIT ?
     `).all(input.core.getTenantId(), workspaceId, previousCursor || '', previousCursor || '', limit + 1);
     const pageRows = rows.slice(0, limit);

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

@@ -0,0 +1,7 @@
+import type { WorkspaceSyncV3FeedCoveragePolicy, WorkspaceSyncV3FeedEntry, WorkspaceSyncV3FeedOperationProjector } from './workspaceSyncV3Feed.js';
+import type { WorkspaceSyncV3CoverageProfile } from './workspaceSyncV3FeedProfile.js';
+/** Dark v7 candidate: v4 ownership plus explicit task card-cover selection. */
+export declare const WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE: WorkspaceSyncV3CoverageProfile;
+export declare const projectWorkspaceSyncV3TaskCoverCoverageOperation: WorkspaceSyncV3FeedOperationProjector;
+export declare const WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_POLICY: WorkspaceSyncV3FeedCoveragePolicy;
+export declare function validateWorkspaceSyncV3TaskCoverCoverageFeedEntry(entry: WorkspaceSyncV3FeedEntry): void;

package/dist/sync/v3/workspaceSyncV3TaskCoverCoverage.js

@@ -0,0 +1,37 @@
+import { createHash } from 'crypto';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { projectWorkspaceSyncV3CombinedOperation, validateWorkspaceSyncV3CombinedFeedEntry, } from './workspaceSyncV3CombinedCoverage.js';
+import { WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE } from './workspaceSyncV3NestedCoverage.js';
+import { projectWorkspaceSyncV3NestedTaskV2Operation, validateWorkspaceSyncV3NestedTaskFeedEntry, WORKSPACE_SYNC_V3_TASK_ATTACHMENT_LINKS_V2_PROJECTION, } from './workspaceSyncV3NestedTaskProjection.js';
+const projections = Object.freeze(WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE.projections.map((projection) => (projection.projectionId === 'task-attachment-links/full-v1'
+    ? WORKSPACE_SYNC_V3_TASK_ATTACHMENT_LINKS_V2_PROJECTION
+    : projection)));
+const identity = Object.freeze({
+    coverageProfileId: 'task-planning-metadata',
+    coverageVersion: 7,
+    projections,
+});
+/** Dark v7 candidate: v4 ownership plus explicit task card-cover selection. */
+export const WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE = Object.freeze({
+    ...identity,
+    coverageDigest: createHash('sha256').update(canonicalWorkspaceSyncJson(identity)).digest('hex'),
+});
+const NESTED_DOMAINS = new Set(['task-comments', 'task-checklist', 'task-attachment-links', 'entity-event']);
+export const projectWorkspaceSyncV3TaskCoverCoverageOperation = (input) => {
+    if (input.rows.some((row) => NESTED_DOMAINS.has(row.domain))) {
+        const nested = projectWorkspaceSyncV3NestedTaskV2Operation(input);
+        if (!nested)
+            throw new Error('Task-cover coverage operation is incomplete.');
+        return nested;
+    }
+    return projectWorkspaceSyncV3CombinedOperation(input);
+};
+export const WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_POLICY = Object.freeze({
+    profile: WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE,
+    projectOperation: projectWorkspaceSyncV3TaskCoverCoverageOperation,
+});
+export function validateWorkspaceSyncV3TaskCoverCoverageFeedEntry(entry) {
+    if (NESTED_DOMAINS.has(entry.domain))
+        return validateWorkspaceSyncV3NestedTaskFeedEntry(entry);
+    return validateWorkspaceSyncV3CombinedFeedEntry(entry);
+}

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

@@ -0,0 +1,6 @@
+export declare const WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR: Readonly<{
+    coverageProfileId: "task-planning-metadata";
+    coverageVersion: 7;
+    coverageDigest: "84b0dee7ac0811234288c1b296357b2ddbcfe82d438ccf90b6bc6e8b5afea0b6";
+}>;
+export declare const WORKSPACE_SYNC_V3_TASK_COVER_EXCLUDED_V2_PROJECTIONS: readonly ("initiative/full-v1" | "taxonomy/full-v1" | "task/root-v1" | "task-relationship/full-v1" | "workstream/full-v1" | "task-comments/full-v1" | "task-checklist/full-v1" | "task-attachment-links/full-v2" | "entity-event/full-v1")[];

package/dist/sync/v3/workspaceSyncV3TaskCoverWireContract.js

@@ -0,0 +1,9 @@
+import { WORKSPACE_SYNC_V3_NESTED_EXCLUDED_V2_PROJECTIONS } from './workspaceSyncV3NestedWireContract.js';
+export const WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_SELECTOR = Object.freeze({
+    coverageProfileId: 'task-planning-metadata',
+    coverageVersion: 7,
+    coverageDigest: '84b0dee7ac0811234288c1b296357b2ddbcfe82d438ccf90b6bc6e8b5afea0b6',
+});
+export const WORKSPACE_SYNC_V3_TASK_COVER_EXCLUDED_V2_PROJECTIONS = Object.freeze(WORKSPACE_SYNC_V3_NESTED_EXCLUDED_V2_PROJECTIONS.map((projection) => (projection === 'task-attachment-links/full-v1'
+    ? 'task-attachment-links/full-v2'
+    : projection)));

package/dist/sync/workspacePullFeed.js

@@ -33,7 +33,8 @@ export async function buildWorkspacePullFeed(input) {
     const excludedProjections = new Set(input.excludedProjections || []);
     const commentsV3Owned = excludedProjections.has('task-comments/full-v1');
     const checklistV3Owned = excludedProjections.has('task-checklist/full-v1');
-    const attachmentsV3Owned = excludedProjections.has('task-attachment-links/full-v1');
+    const attachmentsV3Owned = excludedProjections.has('task-attachment-links/full-v1')
+        || excludedProjections.has('task-attachment-links/full-v2');
     const suppressTaskCarriers = excludedProjections.has('task/root-v1')
         && commentsV3Owned && checklistV3Owned && attachmentsV3Owned;
     const syncCursor = cursor ? { watermark: cursor.u, id: cursor.id } : null;

package/dist/sync/workspaceRepair.d.ts

@@ -22,6 +22,7 @@ export interface WorkspaceRepairManifestDocumentEntry {
     sha256: string;
     sizeBytes: number;
     existsLocally: boolean;
+    contentCheckReliable: boolean;
     source: 'metadata' | 'filesystem';
     publicationState: 'legacy' | 'versioned' | 'deleted' | 'invalid';
     publicationError: string | null;
@@ -36,6 +37,7 @@ export interface WorkspaceRepairManifestAssetEntry {
     sha256: string;
     sizeBytes: number;
     existsLocally: boolean;
+    contentCheckReliable: boolean;
     source: 'metadata' | 'filesystem';
     publicationState: 'legacy' | 'versioned' | 'deleted' | 'invalid';
     publicationError: string | null;
@@ -103,4 +105,5 @@ export declare function scanWorkspaceRepair(input: WorkspaceRepairInput): Worksp
 export declare function applyWorkspaceRepair(input: WorkspaceRepairInput & {
     upsertDocumentWatermark: (workspaceId: string, path: string, contentHash: string, updatedAt: string) => void;
     repairMissingAssetLinks?: boolean;
+    repairMissingContentFiles?: boolean;
 }): WorkspaceRepairApplyResult;

package/dist/sync/workspaceRepair.js

@@ -44,6 +44,14 @@ function collectFiles(dirPath, predicate) {
     visit(root);
     return output;
 }
+function isStorageRootAccessible(basePath) {
+    try {
+        return fs.statSync(basePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 function readFileFingerprint(absolutePath) {
     try {
         const stat = fs.statSync(absolutePath);
@@ -145,6 +153,7 @@ function buildManifestEntriesFromMetadata(tenantId, workspaceId, store, basePath
     const assetDeletes = [];
     const protectedDocumentPaths = new Set();
     const protectedAssetPaths = new Set();
+    const storageRootAccessible = isStorageRootAccessible(basePath);
     const metadataEntries = store.listAllByWorkspace(workspaceId, { includeDeleted: true });
     for (const entry of metadataEntries) {
         const contentKind = entry.kind === 'document' ? 'document' : 'asset';
@@ -192,6 +201,7 @@ function buildManifestEntriesFromMetadata(tenantId, workspaceId, store, basePath
             ? resolveStorageKeyPathInsideRoot(basePath, published.physicalKey)
             : null;
         let existsLocally = false;
+        let contentCheckReliable = true;
         if (!supportsPublishedContent) {
             existsLocally = true;
         }
@@ -200,13 +210,23 @@ function buildManifestEntriesFromMetadata(tenantId, workspaceId, store, basePath
                 existsLocally = true;
             }
             else if (physicalPath) {
-                try {
-                    const stat = fs.statSync(physicalPath);
-                    existsLocally = stat.isFile()
-                        && (published.source !== 'versioned' || stat.size === published.sizeBytes);
-                }
-                catch {
+                if (!storageRootAccessible) {
+                    // The storage root itself couldn't be verified (e.g. an unmounted volume or
+                    // transient I/O failure) — every local file would look "missing" in that state,
+                    // so don't let a whole-root outage masquerade as N individual deletions.
                     existsLocally = false;
+                    contentCheckReliable = false;
+                }
+                else {
+                    try {
+                        const stat = fs.statSync(physicalPath);
+                        existsLocally = stat.isFile()
+                            && (published.source !== 'versioned' || stat.size === published.sizeBytes);
+                    }
+                    catch (error) {
+                        existsLocally = false;
+                        contentCheckReliable = error?.code === 'ENOENT';
+                    }
                 }
             }
         }
@@ -231,6 +251,7 @@ function buildManifestEntriesFromMetadata(tenantId, workspaceId, store, basePath
                 sha256: contentSha256,
                 sizeBytes,
                 existsLocally,
+                contentCheckReliable,
                 source: 'metadata',
                 publicationState,
                 publicationError,
@@ -249,6 +270,7 @@ function buildManifestEntriesFromMetadata(tenantId, workspaceId, store, basePath
             sha256: contentSha256,
             sizeBytes,
             existsLocally,
+            contentCheckReliable,
             source: 'metadata',
             publicationState,
             publicationError,
@@ -307,6 +329,7 @@ export function buildWorkspaceRepairManifest(input) {
                 sha256: fingerprint.sha256,
                 sizeBytes: fingerprint.sizeBytes,
                 existsLocally: true,
+                contentCheckReliable: true,
                 source: 'filesystem',
                 publicationState: 'legacy',
                 publicationError: null,
@@ -337,6 +360,7 @@ export function buildWorkspaceRepairManifest(input) {
             sha256: fingerprint.sha256,
             sizeBytes: fingerprint.sizeBytes,
             existsLocally: true,
+            contentCheckReliable: true,
             source: 'filesystem',
             publicationState: 'legacy',
             publicationError: null,
@@ -466,6 +490,19 @@ export function scanWorkspaceRepair(input) {
             continue;
         }
         if (!document.existsLocally) {
+            if (!document.contentCheckReliable) {
+                issues.push({
+                    code: 'invalid_published_document_content',
+                    entityKind: 'document',
+                    path: document.path,
+                    assetId: document.assetId,
+                    taskId: document.taskId,
+                    repairable: false,
+                    recommendedAction: 'inspect-published-content',
+                    detail: 'Local document file could not be confirmed missing — the storage root was unreachable or the check was inconclusive. Skipped to avoid converting unavailable content into an authoritative deletion.'
+                });
+                continue;
+            }
             issues.push({
                 code: 'missing_document_file',
                 entityKind: 'document',
@@ -564,6 +601,19 @@ export function scanWorkspaceRepair(input) {
         if (!asset.existsLocally) {
             if (protectedAiAvatarAssetPaths.has(asset.path))
                 continue;
+            if (!asset.contentCheckReliable) {
+                issues.push({
+                    code: 'invalid_published_asset_content',
+                    entityKind: 'asset',
+                    path: asset.path,
+                    assetId: asset.assetId,
+                    taskId: asset.taskId,
+                    repairable: false,
+                    recommendedAction: 'inspect-published-content',
+                    detail: 'Local asset file could not be confirmed missing — the storage root was unreachable or the check was inconclusive. Skipped to avoid converting unavailable content into an authoritative deletion.'
+                });
+                continue;
+            }
             issues.push({
                 code: 'missing_asset_file',
                 entityKind: 'asset',
@@ -791,6 +841,17 @@ export function applyWorkspaceRepair(input) {
                 continue;
             }
             if ((issue.code === 'missing_document_file' || issue.code === 'missing_asset_file') && issue.assetId) {
+                if (input.repairMissingContentFiles !== true) {
+                    actionsApplied.push({
+                        code: issue.code,
+                        path: issue.path,
+                        assetId: issue.assetId,
+                        action: issue.recommendedAction,
+                        status: 'skipped',
+                        detail: 'Missing content file repair requires explicit admin confirmation, since a single failed existence check can also mean the content is temporarily unavailable rather than deleted.'
+                    });
+                    continue;
+                }
                 const updated = input.workspaceAssetStore.markDeleted(issue.assetId, workspaceId);
                 actionsApplied.push({
                     code: issue.code,