@taskforcehq/taskforce 0.3.329 → 0.3.330

package/dist/sync/v3/workspaceSyncV3OperatorDiagnostics.js

@@ -116,7 +116,13 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
     `).all(tenantId, workspaceId, since, eventLimit + 1);
     const truncated = eventRows.length > eventLimit;
     const events = eventRows.slice(0, eventLimit);
-    const transfer = { pull: { success: 0, error: 0 }, apply: { success: 0, error: 0 }, server5xx: 0, nonTest409: 0 };
+    const transfer = {
+        pull: { success: 0, error: 0 },
+        apply: { success: 0, error: 0 },
+        server5xx: 0,
+        nonTest409: 0,
+        cursorExpiredResets: 0,
+    };
     const requestTimes = [];
     const observedResponseBytes = [];
     for (const row of events) {
@@ -131,7 +137,10 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
         const requestMs = Number(row.request_ms);
         if (Number.isFinite(requestMs) && requestMs >= 0)
             requestTimes.push(requestMs);
-        const bytes = responseBytes(parseDetails(row.details_json));
+        const details = parseDetails(row.details_json);
+        if (JSON.stringify(details).includes('CURSOR_EXPIRED'))
+            transfer.cursorExpiredResets += 1;
+        const bytes = responseBytes(details);
         if (bytes !== null)
             observedResponseBytes.push(bytes);
     }
@@ -143,6 +152,27 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
           AND coverage_profile_id = ? AND coverage_version = ? AND coverage_digest = ?
           AND created_at >= ?
     `).get(nowIso, tenantId, workspaceId, projection.coverageProfileId, projection.coverageVersion, projection.coverageDigest, since);
+    const storedRepairMaterialization = input.db.prepare(`
+        SELECT
+            COUNT(*) AS count,
+            COALESCE(SUM(CASE WHEN expires_at < ? THEN 1 ELSE 0 END), 0) AS expired,
+            (SELECT COUNT(*)
+             FROM workspace_sync_repair_snapshot_entries entry
+             WHERE entry.tenant_id = ? AND entry.workspace_id = ?) AS entries,
+            (SELECT COUNT(*)
+             FROM workspace_sync_repair_snapshot_entries entry
+             WHERE entry.tenant_id = ? AND entry.workspace_id = ?
+               AND EXISTS (
+                   SELECT 1
+                   FROM workspace_sync_repair_snapshots snapshot
+                   WHERE snapshot.tenant_id = entry.tenant_id
+                     AND snapshot.workspace_id = entry.workspace_id
+                     AND snapshot.snapshot_id = entry.snapshot_id
+                     AND snapshot.expires_at < ?
+               )) AS expired_entries
+        FROM workspace_sync_repair_snapshots
+        WHERE tenant_id = ? AND workspace_id = ?
+    `).get(nowIso, tenantId, workspaceId, tenantId, workspaceId, nowIso, tenantId, workspaceId);
     const stagedEntry = projection.repair ? input.db.prepare(`
         SELECT COUNT(*) AS count
         FROM workspace_sync_coverage_repair_entries
@@ -346,6 +376,10 @@ export function buildWorkspaceSyncV3OperatorDiagnostics(input) {
             materializationsInWindow: integer(repairMaterialization?.count),
             materializedEntriesInWindow: integer(repairMaterialization?.entries),
             unexpiredMaterializations: integer(repairMaterialization?.unexpired),
+            storedMaterializations: integer(storedRepairMaterialization?.count),
+            storedEntries: integer(storedRepairMaterialization?.entries),
+            expiredMaterializations: integer(storedRepairMaterialization?.expired),
+            expiredEntries: integer(storedRepairMaterialization?.expired_entries),
         },
         outbox: {
             captureConfigured, dispatchConfigured, automaticSyncEnabled: automaticSync.enabled,

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

@@ -0,0 +1,17 @@
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
+export declare const DEFAULT_WORKSPACE_SYNC_REPAIR_SNAPSHOT_RETENTION_BATCH_SIZE = 500;
+export interface WorkspaceSyncRepairSnapshotRetentionPolicy {
+    batchSize: number;
+}
+export interface WorkspaceSyncRepairSnapshotRetentionResult {
+    deletedEntries: number;
+    deletedSnapshots: number;
+    remainingExpiredSnapshots: number;
+}
+export declare function resolveWorkspaceSyncRepairSnapshotRetentionPolicy(env?: NodeJS.ProcessEnv): WorkspaceSyncRepairSnapshotRetentionPolicy;
+export declare function pruneExpiredWorkspaceSyncRepairSnapshots(input: {
+    db: DatabaseAdapter;
+    tenantId: string;
+    now?: Date;
+    policy?: WorkspaceSyncRepairSnapshotRetentionPolicy;
+}): WorkspaceSyncRepairSnapshotRetentionResult;

package/dist/sync/v3/workspaceSyncV3RepairSnapshotRetentionService.js

@@ -0,0 +1,64 @@
+export const DEFAULT_WORKSPACE_SYNC_REPAIR_SNAPSHOT_RETENTION_BATCH_SIZE = 500;
+function positiveInteger(value, fallback) {
+    const parsed = Number.parseInt(String(value ?? '').trim(), 10);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+export function resolveWorkspaceSyncRepairSnapshotRetentionPolicy(env = process.env) {
+    return {
+        batchSize: Math.min(10_000, positiveInteger(env.TASKFORCE_SYNC_REPAIR_SNAPSHOT_RETENTION_BATCH_SIZE, DEFAULT_WORKSPACE_SYNC_REPAIR_SNAPSHOT_RETENTION_BATCH_SIZE)),
+    };
+}
+export function pruneExpiredWorkspaceSyncRepairSnapshots(input) {
+    const now = (input.now || new Date()).toISOString();
+    const policy = input.policy || resolveWorkspaceSyncRepairSnapshotRetentionPolicy();
+    return input.db.transaction(() => {
+        const snapshot = input.db.prepare(`
+            SELECT workspace_id, snapshot_id
+            FROM workspace_sync_repair_snapshots
+            WHERE tenant_id = ? AND expires_at < ?
+            ORDER BY expires_at ASC, workspace_id ASC, snapshot_id ASC
+            LIMIT 1
+        `).get(input.tenantId, now);
+        const workspaceId = String(snapshot?.workspace_id || '').trim();
+        const snapshotId = String(snapshot?.snapshot_id || '').trim();
+        let deletedEntries = 0;
+        let deletedSnapshots = 0;
+        if (workspaceId && snapshotId) {
+            const entries = input.db.prepare(`
+                SELECT entry_index
+                FROM workspace_sync_repair_snapshot_entries
+                WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ?
+                ORDER BY entry_index ASC
+                LIMIT ?
+            `).all(input.tenantId, workspaceId, snapshotId, policy.batchSize);
+            if (entries.length > 0) {
+                const result = input.db.prepare(`
+                    DELETE FROM workspace_sync_repair_snapshot_entries
+                    WHERE tenant_id = ? AND workspace_id = ? AND snapshot_id = ?
+                      AND entry_index IN (${entries.map(() => '?').join(', ')})
+                `).run(input.tenantId, workspaceId, snapshotId, ...entries.map((entry) => entry.entry_index));
+                deletedEntries = Number(result.changes || 0);
+            }
+            const snapshotResult = input.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(input.tenantId, workspaceId, snapshotId, now, input.tenantId, workspaceId, snapshotId);
+            deletedSnapshots = Number(snapshotResult.changes || 0);
+        }
+        const remaining = input.db.prepare(`
+            SELECT COUNT(*) AS count
+            FROM workspace_sync_repair_snapshots
+            WHERE tenant_id = ? AND expires_at < ?
+        `).get(input.tenantId, now);
+        return {
+            deletedEntries,
+            deletedSnapshots,
+            remainingExpiredSnapshots: Number(remaining?.count || 0),
+        };
+    })();
+}

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

@@ -0,0 +1,7 @@
+import type { WorkspaceSyncV3FeedCoveragePolicy, WorkspaceSyncV3FeedEntry, WorkspaceSyncV3FeedOperationProjector } from './workspaceSyncV3Feed.js';
+import type { WorkspaceSyncV3CoverageProfile } from './workspaceSyncV3FeedProfile.js';
+/** Dark v8 candidate: active v7 task-cover ownership plus workflow runtime. */
+export declare const WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE: WorkspaceSyncV3CoverageProfile;
+export declare const projectWorkspaceSyncV3WorkflowTaskCoverCoverageOperation: WorkspaceSyncV3FeedOperationProjector;
+export declare const WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_POLICY: WorkspaceSyncV3FeedCoveragePolicy;
+export declare function validateWorkspaceSyncV3WorkflowTaskCoverCoverageFeedEntry(entry: WorkspaceSyncV3FeedEntry): void;

package/dist/sync/v3/workspaceSyncV3WorkflowTaskCoverCoverage.js

@@ -0,0 +1,33 @@
+import { createHash } from 'crypto';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { projectWorkspaceSyncV3TaskCoverCoverageOperation, validateWorkspaceSyncV3TaskCoverCoverageFeedEntry, WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE, } from './workspaceSyncV3TaskCoverCoverage.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_RUNTIME_PROJECTIONS } from './workflowRuntimeSync.js';
+import { projectWorkspaceSyncV3WorkflowRuntimeOperation, validateWorkspaceSyncV3WorkflowRuntimeFeedEntry, } from './workspaceSyncV3WorkflowRuntimeProjection.js';
+const projections = Object.freeze([
+    ...WORKSPACE_SYNC_V3_TASK_COVER_COVERAGE_PROFILE.projections,
+    ...WORKSPACE_SYNC_V3_WORKFLOW_RUNTIME_PROJECTIONS,
+]);
+const identity = Object.freeze({
+    coverageProfileId: 'task-planning-metadata',
+    coverageVersion: 8,
+    projections,
+});
+/** Dark v8 candidate: active v7 task-cover ownership plus workflow runtime. */
+export const WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE = Object.freeze({
+    ...identity,
+    coverageDigest: createHash('sha256').update(canonicalWorkspaceSyncJson(identity)).digest('hex'),
+});
+export const projectWorkspaceSyncV3WorkflowTaskCoverCoverageOperation = (input) => {
+    const workflow = projectWorkspaceSyncV3WorkflowRuntimeOperation(input);
+    return workflow || projectWorkspaceSyncV3TaskCoverCoverageOperation(input);
+};
+export const WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_POLICY = Object.freeze({
+    profile: WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_PROFILE,
+    projectOperation: projectWorkspaceSyncV3WorkflowTaskCoverCoverageOperation,
+});
+export function validateWorkspaceSyncV3WorkflowTaskCoverCoverageFeedEntry(entry) {
+    if (entry.projection.startsWith('workflow-')) {
+        return validateWorkspaceSyncV3WorkflowRuntimeFeedEntry(entry);
+    }
+    return validateWorkspaceSyncV3TaskCoverCoverageFeedEntry(entry);
+}

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

@@ -0,0 +1,7 @@
+export declare const WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR: Readonly<{
+    coverageProfileId: "task-planning-metadata";
+    coverageVersion: 8;
+    coverageDigest: "344c3360d36d383241b212192fe6c2ac1a7694fe521d3b6636559043b7e58253";
+}>;
+/** V2 has neither workflow runtime nor explicit task card-cover projections. */
+export declare const WORKSPACE_SYNC_V3_WORKFLOW_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/workspaceSyncV3WorkflowTaskCoverWireContract.js

@@ -0,0 +1,8 @@
+import { WORKSPACE_SYNC_V3_TASK_COVER_EXCLUDED_V2_PROJECTIONS } from './workspaceSyncV3TaskCoverWireContract.js';
+export const WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_COVERAGE_SELECTOR = Object.freeze({
+    coverageProfileId: 'task-planning-metadata',
+    coverageVersion: 8,
+    coverageDigest: '344c3360d36d383241b212192fe6c2ac1a7694fe521d3b6636559043b7e58253',
+});
+/** V2 has neither workflow runtime nor explicit task card-cover projections. */
+export const WORKSPACE_SYNC_V3_WORKFLOW_TASK_COVER_EXCLUDED_V2_PROJECTIONS = WORKSPACE_SYNC_V3_TASK_COVER_EXCLUDED_V2_PROJECTIONS;

package/dist/sync/workspaceRepair.d.ts

@@ -2,6 +2,7 @@ import type { TaskItem } from '../types.js';
 import type { WorkspaceAssetLinkRole, WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
 import { type AiProfileAvatarPathSource } from './aiProfileAvatarSyncPaths.js';
 import { type WorkspaceSyncPublishedContentResolver } from './engine/workspaceSyncPublishedContentResolver.js';
+import type { WorkspaceSyncContentPullObligationStore } from './engine/workspaceSyncContentPullObligationStore.js';
 export interface WorkspaceRepairManifestTaskEntry {
     id: string;
     archived: boolean;
@@ -52,7 +53,7 @@ export interface WorkspaceRepairManifest {
     assets: WorkspaceRepairManifestAssetEntry[];
     assetDeletes: WorkspaceRepairManifestDeleteEntry[];
 }
-export type WorkspaceRepairIssueCode = 'missing_document_metadata' | 'missing_document_file' | 'stale_document_tombstone' | 'published_document_tombstone_conflict' | 'published_document_live_head_conflict' | 'invalid_published_document_content' | 'missing_asset_metadata' | 'missing_asset_file' | 'stale_asset_tombstone' | 'published_asset_tombstone_conflict' | 'published_asset_live_head_conflict' | 'invalid_published_asset_content' | 'stale_asset_link' | 'missing_asset_link';
+export type WorkspaceRepairIssueCode = 'missing_document_metadata' | 'missing_document_file' | 'stale_document_tombstone' | 'published_document_tombstone_conflict' | 'published_document_live_head_conflict' | 'invalid_published_document_content' | 'document_content_unverified' | 'missing_asset_metadata' | 'missing_asset_file' | 'stale_asset_tombstone' | 'published_asset_tombstone_conflict' | 'published_asset_live_head_conflict' | 'invalid_published_asset_content' | 'asset_content_unverified' | 'stale_asset_link' | 'missing_asset_link';
 export interface WorkspaceRepairIssue {
     code: WorkspaceRepairIssueCode;
     entityKind: 'document' | 'asset' | 'link';
@@ -61,7 +62,7 @@ export interface WorkspaceRepairIssue {
     taskId?: string | null;
     role?: WorkspaceAssetLinkRole;
     repairable: boolean;
-    recommendedAction: 'create-metadata' | 'mark-deleted' | 'revive-metadata' | 'delete-link' | 'create-link' | 'inspect-published-content';
+    recommendedAction: 'create-metadata' | 'mark-deleted' | 'revive-metadata' | 'delete-link' | 'create-link' | 'inspect-published-content' | 'retry-pull';
     detail: string;
 }
 export interface WorkspaceRepairScanResult {
@@ -106,4 +107,6 @@ export declare function applyWorkspaceRepair(input: WorkspaceRepairInput & {
     upsertDocumentWatermark: (workspaceId: string, path: string, contentHash: string, updatedAt: string) => void;
     repairMissingAssetLinks?: boolean;
     repairMissingContentFiles?: boolean;
+    contentPullObligationStore?: WorkspaceSyncContentPullObligationStore;
+    now?: () => string;
 }): WorkspaceRepairApplyResult;

package/dist/sync/workspaceRepair.js

@@ -6,6 +6,7 @@ import { resolveStorageKeyPathInsideRoot } from '../utils/pathSafety.js';
 import { compareWorkspaceMutationOrdering } from './workspaceSyncSurface.js';
 import { relativePathWithinRoot } from '../utils/pathContainment.js';
 import { listReferencedAiProfileAvatarAssetPaths, } from './aiProfileAvatarSyncPaths.js';
+import { WORKSPACE_CONTENT_MANIFEST_VERSION, createWorkspaceContentMetadataFingerprintV1, } from './workspaceContentManifest.js';
 function normalizeWorkspaceId(raw) {
     return String(raw || '').trim() || 'default';
 }
@@ -110,6 +111,68 @@ function getPrimaryTaskId(store, assetId, workspaceId) {
     const links = store.listLinksForAsset(assetId, workspaceId, { includeDeleted: false });
     return links[0]?.taskId || null;
 }
+function buildContentPullObligationInputForAsset(input) {
+    const links = input.store.listLinksForAsset(input.entry.assetId, input.workspaceId, { includeDeleted: false });
+    const primaryLink = links[0] || null;
+    // Mirrors resolveSyncLinkTarget (src/sync/contentSyncState.ts): a task link has no
+    // explicit targetType on the row (it's implied), so it must default to 'task' here
+    // rather than null — otherwise this fingerprint diverges from the one a real content
+    // manifest read (workspacePullFeed.ts) computes for the same task-linked asset, and
+    // the 'exact-version' obligation-resolution path can never match it.
+    const primaryLinkTargetId = String(primaryLink?.targetId || primaryLink?.taskId || '').trim();
+    const linkTargetType = primaryLinkTargetId
+        ? (primaryLink.targetType === 'initiative' || primaryLink.targetType === 'workstream' ? primaryLink.targetType : 'task')
+        : null;
+    const linkTargetId = linkTargetType ? primaryLinkTargetId : null;
+    const taskId = linkTargetType === 'task' ? linkTargetId : null;
+    const metadataFingerprint = input.kind === 'document'
+        ? createWorkspaceContentMetadataFingerprintV1({
+            kind: 'document',
+            metadata: {
+                assetId: input.entry.assetId,
+                documentId: input.entry.documentId,
+                referenceNumber: input.entry.referenceNumber,
+                version: input.entry.version,
+                taskId,
+                linkTargetType,
+                linkTargetId,
+                logicalName: input.entry.logicalName,
+                caption: null,
+                originalFilename: input.entry.originalFilename,
+                linkRole: primaryLink?.role === 'reference' ? 'reference' : 'attachment',
+            },
+        })
+        : createWorkspaceContentMetadataFingerprintV1({
+            kind: 'asset',
+            metadata: {
+                assetId: input.entry.assetId,
+                assetKind: input.entry.kind === 'image' ? 'image' : 'file',
+                mimeType: input.entry.mimeType,
+                referenceNumber: input.entry.referenceNumber,
+                taskId,
+                linkTargetType,
+                linkTargetId,
+                logicalName: input.entry.logicalName,
+                caption: null,
+                originalFilename: input.entry.originalFilename,
+                linkRole: primaryLink?.role || 'attachment',
+            },
+        });
+    const manifest = {
+        manifestVersion: WORKSPACE_CONTENT_MANIFEST_VERSION,
+        kind: input.kind,
+        path: input.path,
+        sha256: String(input.entry.contentSha256 || ''),
+        sizeBytes: Number(input.entry.sizeBytes || 0),
+        updatedAt: input.entry.updatedAt,
+        metadataFingerprint,
+        existsLocally: false,
+    };
+    return {
+        manifest,
+        sourceWatermark: input.entry.updatedAt,
+    };
+}
 function decodePathSegment(raw) {
     try {
         return decodeURIComponent(raw);
@@ -492,14 +555,14 @@ export function scanWorkspaceRepair(input) {
         if (!document.existsLocally) {
             if (!document.contentCheckReliable) {
                 issues.push({
-                    code: 'invalid_published_document_content',
+                    code: 'document_content_unverified',
                     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.'
+                    recommendedAction: 'retry-pull',
+                    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; queued for durable retry instead.'
                 });
                 continue;
             }
@@ -603,14 +666,14 @@ export function scanWorkspaceRepair(input) {
                 continue;
             if (!asset.contentCheckReliable) {
                 issues.push({
-                    code: 'invalid_published_asset_content',
+                    code: 'asset_content_unverified',
                     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.'
+                    recommendedAction: 'retry-pull',
+                    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; queued for durable retry instead.'
                 });
                 continue;
             }
@@ -771,6 +834,7 @@ export function applyWorkspaceRepair(input) {
     const actionsApplied = [];
     const workspaceId = normalizeWorkspaceId(input.workspaceId);
     const activeTaskIds = new Set((input.tasks || []).map((task) => String(task.id || '').trim()).filter(Boolean));
+    const nowIso = () => (input.now ? input.now() : new Date().toISOString());
     const deletedMetadataByPath = new Map();
     if (input.workspaceAssetStore) {
         for (const entry of input.workspaceAssetStore.listAllByWorkspace(workspaceId, { includeDeleted: true })) {
@@ -780,6 +844,69 @@ export function applyWorkspaceRepair(input) {
         }
     }
     for (const issue of scan.issues) {
+        if (issue.code === 'document_content_unverified' || issue.code === 'asset_content_unverified') {
+            if (!input.contentPullObligationStore || !input.workspaceAssetStore || !issue.assetId || !issue.path) {
+                actionsApplied.push({
+                    code: issue.code,
+                    path: issue.path,
+                    assetId: issue.assetId,
+                    taskId: issue.taskId,
+                    action: issue.recommendedAction,
+                    status: 'skipped',
+                    detail: 'No durable content-pull obligation store is available in this runtime; content-availability uncertainty was reported but not queued for retry.'
+                });
+                continue;
+            }
+            try {
+                const assetEntry = input.workspaceAssetStore.get(issue.assetId, workspaceId);
+                if (!assetEntry) {
+                    actionsApplied.push({
+                        code: issue.code,
+                        path: issue.path,
+                        assetId: issue.assetId,
+                        taskId: issue.taskId,
+                        action: issue.recommendedAction,
+                        status: 'skipped',
+                        detail: 'Canonical metadata for this asset was no longer present; skipped queuing a recovery obligation.'
+                    });
+                    continue;
+                }
+                const obligationInput = buildContentPullObligationInputForAsset({
+                    kind: issue.code === 'document_content_unverified' ? 'document' : 'asset',
+                    path: issue.path,
+                    entry: assetEntry,
+                    store: input.workspaceAssetStore,
+                    workspaceId,
+                });
+                input.contentPullObligationStore.upsertMany({
+                    tenantId: input.tenantId,
+                    workspaceId,
+                    obligations: [obligationInput],
+                    now: nowIso(),
+                });
+                actionsApplied.push({
+                    code: issue.code,
+                    path: issue.path,
+                    assetId: issue.assetId,
+                    taskId: issue.taskId,
+                    action: issue.recommendedAction,
+                    status: 'applied',
+                    detail: 'Queued a durable content-pull recovery obligation instead of treating unavailable content as deleted.'
+                });
+            }
+            catch (error) {
+                actionsApplied.push({
+                    code: issue.code,
+                    path: issue.path,
+                    assetId: issue.assetId,
+                    taskId: issue.taskId,
+                    action: issue.recommendedAction,
+                    status: 'failed',
+                    detail: String(error?.message || error || 'Failed to queue a recovery obligation.')
+                });
+            }
+            continue;
+        }
         if (!issue.repairable) {
             actionsApplied.push({
                 code: issue.code,
@@ -947,6 +1074,34 @@ export function applyWorkspaceRepair(input) {
             });
         }
     }
+    if (input.contentPullObligationStore) {
+        const resolutionClaims = [
+            ...scan.snapshot.documents
+                .filter((entry) => entry.existsLocally && entry.assetId)
+                .map((entry) => ({
+                kind: 'document',
+                path: entry.path,
+                sourceWatermark: entry.updatedAt,
+                resolution: 'at-or-before-watermark',
+            })),
+            ...scan.snapshot.assets
+                .filter((entry) => entry.existsLocally && entry.assetId)
+                .map((entry) => ({
+                kind: 'asset',
+                path: entry.path,
+                sourceWatermark: entry.updatedAt,
+                resolution: 'at-or-before-watermark',
+            })),
+        ];
+        if (resolutionClaims.length > 0) {
+            input.contentPullObligationStore.resolveMany({
+                tenantId: input.tenantId,
+                workspaceId,
+                claims: resolutionClaims,
+                now: nowIso(),
+            });
+        }
+    }
     const refreshed = scanWorkspaceRepair(input);
     return {
         ...refreshed,

package/dist/sync/workspaceSyncModel.d.ts

@@ -229,6 +229,9 @@ export interface WorkspaceSyncInitiativeSnapshot {
     order?: number | null;
     attachments?: Array<string | AttachmentItem>;
     isArchived?: boolean;
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+    identityUpdatedAt?: string | null;
     durableRevision?: WorkspaceSyncDurablePlanningRevision<'initiative'>;
 }
 export interface WorkspaceSyncWorkstreamSnapshot {
@@ -245,6 +248,9 @@ export interface WorkspaceSyncWorkstreamSnapshot {
     order?: number | null;
     attachments?: Array<string | AttachmentItem>;
     isArchived?: boolean;
+    icon?: PlanningIdentityIcon | null;
+    color?: PlanningIdentityColor | null;
+    identityUpdatedAt?: string | null;
     durableRevision?: WorkspaceSyncDurablePlanningRevision<'workstream'>;
 }
 export interface WorkspaceSyncPlanningIdentitySnapshot {
@@ -425,6 +431,7 @@ export interface WorkspaceSyncPayload {
     currentInitiativeWatermarks: Map<string, string>;
     currentWorkstreamIds: Set<string>;
     currentWorkstreamWatermarks: Map<string, string>;
+    currentPlanningIdentityWatermarks?: Map<string, string>;
     currentAiProfileIds: Set<string>;
     currentAiProfileWatermarks: Map<string, string>;
     currentAiProfileChangeKeys?: Map<string, string>;
@@ -472,6 +479,7 @@ export interface WorkspaceSyncDeltaDiagnostics {
         taskRelationships?: WorkspaceSyncDomainDeltaDiagnostics;
         initiatives: WorkspaceSyncDomainDeltaDiagnostics;
         workstreams: WorkspaceSyncDomainDeltaDiagnostics;
+        planningIdentities?: WorkspaceSyncDomainDeltaDiagnostics;
         aiProfiles: WorkspaceSyncDomainDeltaDiagnostics;
         documents: WorkspaceSyncDomainDeltaDiagnostics;
         assets: WorkspaceSyncDomainDeltaDiagnostics;
@@ -537,6 +545,18 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     assets?: WorkspaceSyncAssetSnapshot[];
     currentDocumentPaths?: Iterable<string>;
     currentAssetPaths?: Iterable<string>;
+    /**
+     * Positive completeness signal for the current-workspace document/asset
+     * snapshot used to compute deleteDocumentPaths/deleteAssetPaths. Explicit
+     * `false` means the snapshot is known failed, partial, stale, for the wrong
+     * workspace, or not yet hydrated — the delete-diff for that domain is
+     * suppressed entirely rather than trusted. Omitted/undefined defaults to
+     * `true` for callers (tests, other pure-function consumers) that don't model
+     * hydration state; the real browser sync orchestrator always passes the
+     * verified value.
+     */
+    documentsSnapshotComplete?: boolean;
+    assetsSnapshotComplete?: boolean;
     documentReviewSessions?: WorkspaceSyncDocumentReviewSessionSnapshot[];
     documentReviewComments?: WorkspaceSyncDocumentReviewCommentSnapshot[];
     annotatedAttachmentSessions?: WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
@@ -549,6 +569,7 @@ export declare function buildWorkspaceSyncPayloadModel(input: {
     lastPushedInitiativeWatermarks?: Map<string, string>;
     lastPushedWorkstreamIds?: Set<string>;
     lastPushedWorkstreamWatermarks?: Map<string, string>;
+    lastPushedPlanningIdentityWatermarks?: Map<string, string>;
     lastPushedAiProfileIds?: Set<string>;
     lastPushedAiProfileWatermarks?: Map<string, string>;
     lastPushedDocumentPaths?: Set<string>;

package/dist/sync/workspaceSyncModel.js

@@ -223,6 +223,8 @@ export function buildWorkspaceSyncPayloadModel(input) {
             return true;
         return previousWorkstreamWatermarks.get(change.workstream.id) !== change.workstream.updatedAt;
     });
+    const previousPlanningIdentityWatermarks = input.lastPushedPlanningIdentityWatermarks;
+    const currentPlanningIdentityWatermarks = new Map();
     const planningIdentityUpsertChanges = [
         ...(Array.isArray(input.initiatives) ? input.initiatives : []).map((initiative) => ({
             entityType: 'initiative',
@@ -240,7 +242,13 @@ export function buildWorkspaceSyncPayloadModel(input) {
         })),
     ]
         .filter((identity) => identity.entityId.length > 0 && Number.isFinite(Date.parse(identity.updatedAt)))
-        .map((identity) => ({ op: 'planning-identity-upsert', identity }));
+        .map((identity) => {
+        const identityKey = `${identity.entityType}:${identity.entityId}`;
+        currentPlanningIdentityWatermarks.set(identityKey, identity.updatedAt);
+        return { op: 'planning-identity-upsert', identity, identityKey };
+    })
+        .filter((change) => previousPlanningIdentityWatermarks?.get(change.identityKey) !== change.identity.updatedAt)
+        .map(({ identityKey: _identityKey, ...change }) => change);
     const currentAiProfileIds = new Set((Array.isArray(input.aiProfiles) ? input.aiProfiles : [])
         .map((profile) => String(profile?.id || '').trim())
         .filter((profileId) => profileId.length > 0));
@@ -312,9 +320,18 @@ export function buildWorkspaceSyncPayloadModel(input) {
     });
     const currentDocumentPaths = normalizeWorkspaceSyncPathSet(input.currentDocumentPaths, (Array.isArray(input.documents) ? input.documents : [])
         .map((doc) => String(doc?.path || '').trim()));
-    const deleteDocumentPaths = new Set(Array.from(input.lastPushedDocumentPaths || new Set())
-        .map((docPath) => String(docPath || '').trim())
-        .filter((docPath) => docPath.length > 0 && !currentDocumentPaths.has(docPath)));
+    // A raw set-difference against the previous push is only trustworthy when the
+    // current snapshot is a verified-complete, current-workspace read. A failed,
+    // partial, stale, or not-yet-hydrated snapshot must never be interpreted as
+    // deletion intent — so documentsSnapshotComplete === false suppresses the
+    // entire delete-diff for this cycle rather than trusting a plausible-looking
+    // but potentially wrong difference.
+    const documentsSnapshotComplete = input.documentsSnapshotComplete !== false;
+    const deleteDocumentPaths = documentsSnapshotComplete
+        ? new Set(Array.from(input.lastPushedDocumentPaths || new Set())
+            .map((docPath) => String(docPath || '').trim())
+            .filter((docPath) => docPath.length > 0 && !currentDocumentPaths.has(docPath)))
+        : new Set();
     const currentDocumentWatermarks = new Map((Array.isArray(input.documents) ? input.documents : [])
         .map((doc) => [String(doc?.path || '').trim(), String(doc?.updatedAt || '').trim()])
         .filter(([docPath]) => docPath.length > 0));
@@ -349,9 +366,14 @@ export function buildWorkspaceSyncPayloadModel(input) {
     });
     const currentAssetPaths = normalizeWorkspaceSyncPathSet(input.currentAssetPaths, (Array.isArray(input.assets) ? input.assets : [])
         .map((asset) => String(asset?.path || '').trim()));
-    const deleteAssetPaths = new Set(Array.from(input.lastPushedAssetPaths || new Set())
-        .map((assetPath) => String(assetPath || '').trim())
-        .filter((assetPath) => assetPath.length > 0 && !currentAssetPaths.has(assetPath)));
+    // See documentsSnapshotComplete above — the same admission boundary applies
+    // to assets.
+    const assetsSnapshotComplete = input.assetsSnapshotComplete !== false;
+    const deleteAssetPaths = assetsSnapshotComplete
+        ? new Set(Array.from(input.lastPushedAssetPaths || new Set())
+            .map((assetPath) => String(assetPath || '').trim())
+            .filter((assetPath) => assetPath.length > 0 && !currentAssetPaths.has(assetPath)))
+        : new Set();
     const currentAssetWatermarks = new Map((Array.isArray(input.assets) ? input.assets : [])
         .map((asset) => [String(asset?.path || '').trim(), String(asset?.updatedAt || '').trim()])
         .filter(([assetPath]) => assetPath.length > 0));
@@ -958,6 +980,7 @@ export function buildWorkspaceSyncPayloadModel(input) {
         currentInitiativeWatermarks,
         currentWorkstreamIds,
         currentWorkstreamWatermarks,
+        currentPlanningIdentityWatermarks,
         currentAiProfileIds,
         currentAiProfileWatermarks,
         currentAiProfileChangeKeys,
@@ -1012,6 +1035,11 @@ export function buildWorkspaceSyncPayloadModel(input) {
                     baselineCount: previousWorkstreamWatermarks?.size || 0,
                     upsertCount: workstreamUpsertChanges.length
                 }),
+                planningIdentities: resolveDomainDeltaDiagnostics({
+                    currentCount: currentPlanningIdentityWatermarks.size,
+                    baselineCount: previousPlanningIdentityWatermarks?.size || 0,
+                    upsertCount: planningIdentityUpsertChanges.length
+                }),
                 aiProfiles: resolveDomainDeltaDiagnostics({
                     currentCount: currentAiProfileIds.size,
                     baselineCount: previousAiProfileWatermarks?.size || 0,

package/dist/sync/workspaceSyncState.d.ts

@@ -11,6 +11,7 @@ export interface WorkspaceSyncPushBaselineSnapshot {
     taskRelationshipChangeKeys?: Array<[string, string]>;
     initiativeWatermarks: Array<[string, string]>;
     workstreamWatermarks: Array<[string, string]>;
+    planningIdentityWatermarks?: Array<[string, string]>;
     aiProfileWatermarks: Array<[string, string]>;
     aiProfileChangeKeys?: Array<[string, string]>;
     taskforceAgentWatermarks?: Array<[string, string]>;

package/dist/sync/workspaceSyncV2SnapshotBuilder.d.ts

@@ -19,6 +19,9 @@ export interface WorkspaceSyncV2SnapshotInput {
     assets?: readonly WorkspaceSyncAssetSnapshot[];
     currentDocumentPaths?: ReadonlySet<string>;
     currentAssetPaths?: ReadonlySet<string>;
+    /** See WorkspaceSyncPayloadModel's documentsSnapshotComplete/assetsSnapshotComplete. */
+    documentsSnapshotComplete?: boolean;
+    assetsSnapshotComplete?: boolean;
     documentReviewSessions?: readonly WorkspaceSyncDocumentReviewSessionSnapshot[];
     documentReviewComments?: readonly WorkspaceSyncDocumentReviewCommentSnapshot[];
     annotatedAttachmentSessions?: readonly WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
@@ -45,6 +48,8 @@ export interface WorkspaceSyncV2FrozenSnapshot {
     readonly assets: readonly WorkspaceSyncAssetSnapshot[];
     readonly currentDocumentPaths: ReadonlySet<string>;
     readonly currentAssetPaths: ReadonlySet<string>;
+    readonly documentsSnapshotComplete: boolean;
+    readonly assetsSnapshotComplete: boolean;
     readonly documentReviewSessions: readonly WorkspaceSyncDocumentReviewSessionSnapshot[];
     readonly documentReviewComments: readonly WorkspaceSyncDocumentReviewCommentSnapshot[];
     readonly annotatedAttachmentSessions: readonly WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
@@ -64,6 +69,7 @@ export interface WorkspaceSyncV2PushBaseline {
     readonly lastPushedInitiativeWatermarks: ReadonlyMap<string, string>;
     readonly lastPushedWorkstreamIds: ReadonlySet<string>;
     readonly lastPushedWorkstreamWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedPlanningIdentityWatermarks?: ReadonlyMap<string, string>;
     readonly lastPushedAiProfileIds: ReadonlySet<string>;
     readonly lastPushedAiProfileWatermarks: ReadonlyMap<string, string>;
     readonly lastPushedAiProfileChangeKeys: ReadonlyMap<string, string>;