@taskforcehq/taskforce 0.3.329 → 0.3.332

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

@@ -46,6 +46,10 @@ export interface WorkspaceSyncV3OperatorDiagnosticsSnapshot {
         materializationsInWindow: number;
         materializedEntriesInWindow: number;
         unexpiredMaterializations: number;
+        storedMaterializations: number;
+        storedEntries: number;
+        expiredMaterializations: number;
+        expiredEntries: number;
     };
     outbox: {
         captureConfigured: boolean;
@@ -74,6 +78,7 @@ export interface WorkspaceSyncV3OperatorDiagnosticsSnapshot {
         };
         server5xx: number;
         nonTest409: number;
+        cursorExpiredResets: number;
         requestP95Ms: number | null;
         maxObservedResponseBytes: number | null;
     };

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/workspaceSyncV3WorkflowRuntimeApply.d.ts

@@ -14,4 +14,5 @@ export declare function prepareWorkspaceSyncV3WorkflowRuntimeApply(input: {
     store: WorkflowStore;
     workspaceId: string;
     entries: WorkspaceSyncV3FeedEntry[];
+    replaceAuthoritativeHistoryExecutionIds?: ReadonlySet<string>;
 }): WorkspaceSyncV3WorkflowRuntimeApplyPlan;

package/dist/sync/v3/workspaceSyncV3WorkflowRuntimeApply.js

@@ -1,5 +1,5 @@
 import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
-import { validateWorkflowExecutionEventSyncPayload, validateWorkflowExecutionRootSyncPayload, validateWorkflowPublishedDefinitionSyncPayload, validateWorkflowRuntimeEventHistory, } from './workflowRuntimeSync.js';
+import { serializeWorkflowPublishedDefinitionSyncPayload, validateWorkflowExecutionEventSyncPayload, validateWorkflowExecutionRootSyncPayload, validateWorkflowPublishedDefinitionSyncPayload, validateWorkflowRuntimeEventHistory, } from './workflowRuntimeSync.js';
 import { validateWorkspaceSyncV3WorkflowRuntimeFeedEntry } from './workspaceSyncV3WorkflowRuntimeProjection.js';
 const WORKFLOW_PROJECTIONS = new Set([
     'workflow-published-definition/full-v2',
@@ -9,6 +9,19 @@ const WORKFLOW_PROJECTIONS = new Set([
 function compareEvents(left, right) {
     return canonicalWorkspaceSyncJson(left) === canonicalWorkspaceSyncJson(right);
 }
+function executionIdentity(root) {
+    const execution = root.execution;
+    return canonicalWorkspaceSyncJson({
+        id: execution.id,
+        tenantId: execution.tenantId,
+        workspaceId: execution.workspaceId,
+        taskId: execution.taskId,
+        workflowTemplateId: execution.workflowTemplateId,
+        workflowVersionId: execution.workflowVersionId,
+        createdByActorId: execution.createdByActorId || null,
+        createdAt: execution.createdAt,
+    });
+}
 function mergeEventHistory(input) {
     const local = [...input.local].sort((left, right) => left.sequenceNumber - right.sequenceNumber);
     const incoming = [...input.incoming].sort((left, right) => left.sequenceNumber - right.sequenceNumber);
@@ -47,6 +60,19 @@ function derivedTemplate(definition, existing) {
         deletedAt: null,
     };
 }
+function installedPublishedDefinition(store, workspaceId, versionId) {
+    const version = store.getVersion(workspaceId, versionId);
+    if (!version || version.status !== 'published')
+        return null;
+    const template = store.getTemplate(workspaceId, version.workflowTemplateId);
+    if (!template)
+        return null;
+    return serializeWorkflowPublishedDefinitionSyncPayload({
+        template,
+        version,
+        steps: store.listSteps(workspaceId, version.id),
+    });
+}
 /**
  * Builds complete workflow aggregates before any revision is accepted. A root
  * entry is the atomic install trigger; definition and event entries only carry
@@ -56,6 +82,7 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
     const workflowEntries = new Set(input.entries.filter((entry) => WORKFLOW_PROJECTIONS.has(entry.projection)));
     const definitions = new Map();
     const roots = new Map();
+    const rootEntries = new Map();
     const eventsByExecution = new Map();
     for (const entry of workflowEntries) {
         validateWorkspaceSyncV3WorkflowRuntimeFeedEntry(entry);
@@ -68,10 +95,23 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
         }
         else if (entry.projection === 'workflow-execution/root-v1') {
             const root = validateWorkflowExecutionRootSyncPayload(entry.payload);
-            if (roots.has(root.execution.id)) {
-                throw new Error(`Workflow execution root is duplicated in one apply batch: ${root.execution.id}.`);
+            const existing = roots.get(root.execution.id);
+            const existingEntry = rootEntries.get(root.execution.id);
+            if (existing && existingEntry) {
+                if (executionIdentity(existing) !== executionIdentity(root)) {
+                    throw new Error(`Workflow execution root identity changes in one apply batch: ${root.execution.id}.`);
+                }
+                const revision = BigInt(entry.entityRevision);
+                const existingRevision = BigInt(existingEntry.entityRevision);
+                if (revision === existingRevision
+                    && canonicalWorkspaceSyncJson(existing) !== canonicalWorkspaceSyncJson(root)) {
+                    throw new Error(`Workflow execution root revision conflicts in one apply batch: ${root.execution.id}.`);
+                }
+                if (revision <= existingRevision)
+                    continue;
             }
             roots.set(root.execution.id, root);
+            rootEntries.set(root.execution.id, entry);
         }
         else {
             const event = validateWorkflowExecutionEventSyncPayload(entry.payload).event;
@@ -87,6 +127,7 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
     }
     const assignments = new Map();
     for (const [executionId, root] of roots) {
+        const replaceAuthoritativeHistory = Boolean(input.replaceAuthoritativeHistoryExecutionIds?.has(executionId));
         const local = input.store.getAssignmentForExecutionSync(input.workspaceId, executionId);
         const definition = definitions.get(root.execution.workflowVersionId)
             || (local ? {
@@ -97,12 +138,13 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
                 },
                 version: local.version,
                 steps: local.steps,
-            } : null);
+            } : null)
+            || installedPublishedDefinition(input.store, input.workspaceId, root.execution.workflowVersionId);
         if (!definition) {
             throw new Error(`Workflow execution ${executionId} is missing its published definition.`);
         }
         const merged = mergeEventHistory({
-            local: local?.events || [],
+            local: replaceAuthoritativeHistory ? [] : local?.events || [],
             incoming: eventsByExecution.get(executionId) || [],
         });
         const execution = merged.localExtension && local
@@ -131,12 +173,15 @@ export function prepareWorkspaceSyncV3WorkflowRuntimeApply(input) {
                 return;
             if (entry.projection !== 'workflow-execution/root-v1')
                 return;
+            if (rootEntries.get(entry.entityId) !== entry)
+                return;
             const assignment = assignments.get(entry.entityId);
             if (!assignment)
                 throw new Error(`Workflow execution apply plan is missing ${entry.entityId}.`);
             input.store.installAssignmentForSync(input.workspaceId, assignment, {
                 authority: 'cloud-execution',
                 expectedTaskId: assignment.execution.taskId,
+                replaceAuthoritativeHistory: input.replaceAuthoritativeHistoryExecutionIds?.has(entry.entityId),
             });
         },
     };

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,