@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/storage/workspaceAssetStore.d.ts

@@ -4,6 +4,18 @@ export type WorkspaceAssetKind = 'document' | 'image' | 'file';
 export type WorkspaceAssetScanStatus = 'pending' | 'clean' | 'infected' | 'failed';
 export type WorkspaceAssetLinkRole = 'attachment' | 'image' | 'reference';
 export type WorkspaceAssetLinkTargetType = 'task' | 'initiative' | 'workstream';
+export declare class WorkspaceAssetDurableInitiativeLinkError extends Error {
+    readonly initiativeIds: string[];
+    readonly code = "INITIATIVE_ATTACHMENT_DURABLE_SYNC_REQUIRED";
+    readonly statusCode = 409;
+    constructor(initiativeIds: string[]);
+}
+export declare class WorkspaceAssetDurableWorkstreamLinkError extends Error {
+    readonly workstreamIds: string[];
+    readonly code = "WORKSTREAM_ATTACHMENT_DURABLE_SYNC_REQUIRED";
+    readonly statusCode = 409;
+    constructor(workstreamIds: string[]);
+}
 export interface WorkspaceAssetEntry {
     assetId: string;
     tenantId: string;
@@ -29,6 +41,18 @@ export interface WorkspaceAssetEntry {
     deletedAt: string | null;
     purgeAfter: string | null;
 }
+/**
+ * Document-specific canonical read model.
+ *
+ * `logical_name` and `document_id` remain physical compatibility fields on
+ * `workspace_assets` while v2 document sync is authoritative. Ordinary
+ * document code should use this projection so asset identity and editable
+ * title do not leak those storage aliases beyond the store boundary.
+ */
+export interface WorkspaceDocumentEntry extends Omit<WorkspaceAssetEntry, 'kind' | 'logicalName' | 'documentId'> {
+    kind: 'document';
+    title: string | null;
+}
 export interface WorkspaceAssetLinkEntry {
     tenantId: string;
     workspaceId: string;
@@ -48,11 +72,40 @@ export declare class WorkspaceAssetStore {
     private readonly tenantId;
     private supportsTargetTypeCache;
     constructor(db: DatabaseAdapter, tenantId: string);
+    private isPlanningTargetDurablyOwned;
+    assertAssetDeletionAllowed(assetIdRaw: string, workspaceIdRaw: string): void;
+    private runDurableAssetMutation;
+    private runLegacySyncLinkMutation;
     private supportsTargetType;
     private normalizePersistedAsset;
     get(assetIdRaw: string, workspaceIdRaw?: string): WorkspaceAssetEntry | null;
+    getDocument(assetIdRaw: string, workspaceIdRaw?: string): WorkspaceDocumentEntry | null;
+    renameDocumentTitle(input: {
+        workspaceId: string;
+        assetId: string;
+        title: string;
+        updatedAt: string;
+    }): WorkspaceDocumentEntry | null;
     getByStorageKey(storageKeyRaw: string, workspaceIdRaw: string): WorkspaceAssetEntry | null;
     getByKindAndReferenceNumber(workspaceIdRaw: string, kind: WorkspaceAssetKind, referenceNumberRaw: unknown): WorkspaceAssetEntry | null;
+    updateDocumentContentMetadataIfVersion(input: {
+        workspaceId: string;
+        assetId: string;
+        expectedVersion: number;
+        contentSha256: string;
+        sizeBytes: number;
+        mimeType: string;
+        scanStatus: WorkspaceAssetScanStatus;
+        scanEngine?: string | null;
+        scanDetails?: string | null;
+        updatedAt: string;
+    }): WorkspaceAssetEntry | null;
+    /**
+     * Force an existing readable asset to a cloud-authoritative D-/I- number.
+     * If another local asset already owns that number, reassign the conflict
+     * to the next free number so durable nested attachment links can install.
+     */
+    adoptReadableReferenceNumber(workspaceIdRaw: string, assetIdRaw: string, referenceNumberRaw: unknown): WorkspaceAssetEntry;
     upsertAsset(input: {
         assetId: string;
         workspaceId: string;
@@ -91,6 +144,15 @@ export declare class WorkspaceAssetStore {
         kind?: WorkspaceAssetKind;
         pageSize?: number;
     }): WorkspaceAssetEntry[];
+    listDocumentsByWorkspace(workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+        pageSize?: number;
+    }): WorkspaceDocumentEntry[];
+    listAllNormalizedByWorkspace(workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+        kind?: WorkspaceAssetKind;
+        pageSize?: number;
+    }): WorkspaceAssetEntry[];
     listAll(options?: {
         includeDeleted?: boolean;
         kind?: WorkspaceAssetKind;
@@ -99,6 +161,7 @@ export declare class WorkspaceAssetStore {
     listQuarantined(limitRaw?: number): WorkspaceAssetEntry[];
     listPurgeCandidates(now?: Date, limitRaw?: number): WorkspaceAssetEntry[];
     markDeleted(assetIdRaw: string, workspaceIdRaw: string, deletedAt?: string, purgeAfter?: string | null): WorkspaceAssetEntry | null;
+    restoreDeleted(assetIdRaw: string, workspaceIdRaw: string, restoredUpdatedAt?: string): WorkspaceAssetEntry | null;
     remove(assetIdRaw: string, workspaceIdRaw: string): boolean;
     upsertLink(input: {
         workspaceId: string;
@@ -113,6 +176,7 @@ export declare class WorkspaceAssetStore {
         updatedAt?: string;
         deletedAt?: string | null;
     }): WorkspaceAssetLinkEntry;
+    upsertLegacySyncLink(input: Parameters<WorkspaceAssetStore['upsertLink']>[0]): WorkspaceAssetLinkEntry | null;
     listLinksForTask(taskIdRaw: string, workspaceIdRaw: string, options?: {
         includeDeleted?: boolean;
     }): WorkspaceAssetLinkEntry[];
@@ -122,6 +186,9 @@ export declare class WorkspaceAssetStore {
     listLinksForAsset(assetIdRaw: string, workspaceIdRaw: string, options?: {
         includeDeleted?: boolean;
     }): WorkspaceAssetLinkEntry[];
+    listLinksForWorkspace(workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+    }): WorkspaceAssetLinkEntry[];
     deleteLink(input: {
         workspaceId: string;
         assetId: string;
@@ -130,5 +197,8 @@ export declare class WorkspaceAssetStore {
         targetId?: string;
         role: WorkspaceAssetLinkRole;
         hardDelete?: boolean;
+        allowDurableInitiativeWrite?: boolean;
+        allowDurableWorkstreamWrite?: boolean;
     }): boolean;
+    deleteLegacySyncLink(input: Parameters<WorkspaceAssetStore['deleteLink']>[0]): boolean;
 }

package/dist/storage/workspaceAssetStore.js

@@ -1,4 +1,25 @@
 import { normalizeCanonicalAssetKind } from '../utils/canonicalAssetKind.js';
+import { WorkspaceSyncDurabilityStore } from '../sync/v3/syncDurabilityStore.js';
+export class WorkspaceAssetDurableInitiativeLinkError extends Error {
+    initiativeIds;
+    code = 'INITIATIVE_ATTACHMENT_DURABLE_SYNC_REQUIRED';
+    statusCode = 409;
+    constructor(initiativeIds) {
+        super('Remove this asset from its durable initiatives before deleting or unlinking it.');
+        this.initiativeIds = initiativeIds;
+        this.name = 'WorkspaceAssetDurableInitiativeLinkError';
+    }
+}
+export class WorkspaceAssetDurableWorkstreamLinkError extends Error {
+    workstreamIds;
+    code = 'WORKSTREAM_ATTACHMENT_DURABLE_SYNC_REQUIRED';
+    statusCode = 409;
+    constructor(workstreamIds) {
+        super('Remove this asset from its durable workstreams before deleting or unlinking it.');
+        this.workstreamIds = workstreamIds;
+        this.name = 'WorkspaceAssetDurableWorkstreamLinkError';
+    }
+}
 function normalizeId(raw, fallback = '') {
     return String(raw || '').trim() || fallback;
 }
@@ -46,6 +67,17 @@ function mapAssetRow(row) {
         purgeAfter: row.purge_after == null ? null : String(row.purge_after)
     };
 }
+function toWorkspaceDocumentEntry(entry) {
+    if (entry.kind !== 'document')
+        return null;
+    const { logicalName, documentId, ...canonical } = entry;
+    void documentId;
+    return {
+        ...canonical,
+        kind: 'document',
+        title: logicalName,
+    };
+}
 function mapLinkRow(row) {
     const targetType = String(row.target_type || 'task').trim();
     const targetId = String(row.task_id || '').trim();
@@ -82,6 +114,147 @@ export class WorkspaceAssetStore {
         this.db = db;
         this.tenantId = tenantId;
     }
+    isPlanningTargetDurablyOwned(workspaceId, targetType, targetId) {
+        if (targetType !== 'initiative' && targetType !== 'workstream')
+            return false;
+        try {
+            const row = this.db.prepare(`
+                SELECT 1 AS owned
+                WHERE EXISTS (
+                    SELECT 1 FROM workspace_sync_entity_revisions AS revision
+                    WHERE revision.tenant_id = ? AND revision.workspace_id = ?
+                      AND revision.contract_version = 3 AND revision.domain = ?
+                      AND revision.entity_id = ? AND revision.entity_revision > 0
+                ) OR EXISTS (
+                    SELECT 1 FROM workspace_sync_outbox AS outbox
+                    WHERE outbox.tenant_id = ? AND outbox.workspace_id = ?
+                      AND outbox.contract_version = 3 AND outbox.domain = ?
+                      AND outbox.entity_id = ? AND outbox.status IN ('pending', 'in_flight', 'blocked')
+                )
+            `).get(this.tenantId, workspaceId, targetType, targetId, this.tenantId, workspaceId, targetType, targetId);
+            return Number(row?.owned || 0) === 1;
+        }
+        catch (error) {
+            if (/no such table|does not exist/i.test(String(error?.message || error || '')))
+                return false;
+            throw error;
+        }
+    }
+    assertAssetDeletionAllowed(assetIdRaw, workspaceIdRaw) {
+        const assetId = normalizeId(assetIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!assetId || !this.supportsTargetType())
+            return;
+        let rows;
+        try {
+            rows = this.db.prepare(`
+            SELECT DISTINCT link.target_type, link.task_id AS target_id
+            FROM workspace_asset_links AS link
+            WHERE link.tenant_id = ? AND link.workspace_id = ? AND link.asset_id = ?
+              AND link.target_type IN ('initiative', 'workstream') AND link.deleted_at IS NULL
+              AND (
+                EXISTS (
+                    SELECT 1 FROM workspace_sync_entity_revisions AS revision
+                    WHERE revision.tenant_id = link.tenant_id
+                      AND revision.workspace_id = link.workspace_id
+                      AND revision.contract_version = 3
+                      AND revision.domain = link.target_type
+                      AND revision.entity_id = link.task_id
+                      AND revision.entity_revision > 0
+                )
+                OR EXISTS (
+                    SELECT 1 FROM workspace_sync_outbox AS outbox
+                    WHERE outbox.tenant_id = link.tenant_id
+                      AND outbox.workspace_id = link.workspace_id
+                      AND outbox.contract_version = 3
+                      AND outbox.domain = link.target_type
+                      AND outbox.entity_id = link.task_id
+                      AND outbox.status IN ('pending', 'in_flight', 'blocked')
+                )
+              )
+            ORDER BY link.target_type, link.task_id
+            `).all(this.tenantId, workspaceId, assetId);
+        }
+        catch (error) {
+            if (/no such table|does not exist/i.test(String(error?.message || error || '')))
+                return;
+            throw error;
+        }
+        const initiativeIds = rows
+            .filter((row) => row.target_type === 'initiative')
+            .map((row) => String(row.target_id || '').trim()).filter(Boolean);
+        if (initiativeIds.length > 0)
+            throw new WorkspaceAssetDurableInitiativeLinkError(initiativeIds);
+        const workstreamIds = rows
+            .filter((row) => row.target_type === 'workstream')
+            .map((row) => String(row.target_id || '').trim()).filter(Boolean);
+        if (workstreamIds.length > 0)
+            throw new WorkspaceAssetDurableWorkstreamLinkError(workstreamIds);
+    }
+    runDurableAssetMutation(workspaceId, assetId, apply) {
+        const now = new Date().toISOString();
+        const store = new WorkspaceSyncDurabilityStore(this.db);
+        try {
+            return store.runWorkspaceDomainCoexistenceTransaction({
+                tenantId: this.tenantId,
+                workspaceId,
+                direction: 'cloud-push',
+                targets: [
+                    { domain: 'initiative-assets', entityId: '__workspace__' },
+                    { domain: 'workstream-assets', entityId: '__workspace__' },
+                ],
+                now,
+                apply: () => store.runWorkspaceDomainCoexistenceTransaction({
+                    tenantId: this.tenantId,
+                    workspaceId,
+                    direction: 'local-pull',
+                    targets: [
+                        { domain: 'initiative-assets', entityId: '__workspace__' },
+                        { domain: 'workstream-assets', entityId: '__workspace__' },
+                    ],
+                    now,
+                    apply: () => {
+                        this.assertAssetDeletionAllowed(assetId, workspaceId);
+                        return apply();
+                    },
+                }),
+            });
+        }
+        catch (error) {
+            if (/no such table|does not exist/i.test(String(error?.message || error || ''))) {
+                this.assertAssetDeletionAllowed(assetId, workspaceId);
+                return apply();
+            }
+            throw error;
+        }
+    }
+    runLegacySyncLinkMutation(workspaceId, targetType, targetId, protectedResult, apply) {
+        if (targetType !== 'initiative' && targetType !== 'workstream')
+            return apply();
+        const now = new Date().toISOString();
+        const store = new WorkspaceSyncDurabilityStore(this.db);
+        const targets = [
+            { domain: 'initiative-assets', entityId: '__workspace__' },
+            { domain: 'workstream-assets', entityId: '__workspace__' },
+        ];
+        return store.runWorkspaceDomainCoexistenceTransaction({
+            tenantId: this.tenantId,
+            workspaceId,
+            direction: 'cloud-push',
+            targets,
+            now,
+            apply: () => store.runWorkspaceDomainCoexistenceTransaction({
+                tenantId: this.tenantId,
+                workspaceId,
+                direction: 'local-pull',
+                targets,
+                now,
+                apply: () => this.isPlanningTargetDurablyOwned(workspaceId, targetType, targetId)
+                    ? protectedResult
+                    : apply(),
+            }),
+        });
+    }
     supportsTargetType() {
         if (this.supportsTargetTypeCache !== null)
             return this.supportsTargetTypeCache;
@@ -142,6 +315,27 @@ export class WorkspaceAssetStore {
         `).get(this.tenantId, workspaceId, assetId);
         return row ? this.normalizePersistedAsset(mapAssetRow(row)) : null;
     }
+    getDocument(assetIdRaw, workspaceIdRaw) {
+        const asset = this.get(assetIdRaw, workspaceIdRaw);
+        return asset ? toWorkspaceDocumentEntry(asset) : null;
+    }
+    renameDocumentTitle(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const assetId = normalizeId(input.assetId);
+        const title = normalizeId(input.title);
+        const updatedAt = normalizeId(input.updatedAt);
+        if (!assetId || !title || !updatedAt)
+            return null;
+        const result = this.db.prepare(`
+            UPDATE workspace_assets
+            SET logical_name = ?, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+              AND kind = 'document' AND deleted_at IS NULL
+        `).run(title, updatedAt, this.tenantId, workspaceId, assetId);
+        if (Number(result?.changes || 0) !== 1)
+            return null;
+        return this.getDocument(assetId, workspaceId);
+    }
     getByStorageKey(storageKeyRaw, workspaceIdRaw) {
         const storageKey = normalizeId(storageKeyRaw);
         const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
@@ -151,7 +345,10 @@ export class WorkspaceAssetStore {
             SELECT *
             FROM workspace_assets
             WHERE tenant_id = ? AND workspace_id = ? AND storage_key = ?
-            ORDER BY updated_at DESC, asset_id ASC
+            ORDER BY
+                CASE WHEN deleted_at IS NULL THEN 0 ELSE 1 END ASC,
+                updated_at DESC,
+                asset_id ASC
             LIMIT 1
         `).get(this.tenantId, workspaceId, storageKey);
         return row ? this.normalizePersistedAsset(mapAssetRow(row)) : null;
@@ -169,6 +366,103 @@ export class WorkspaceAssetStore {
         `).get(this.tenantId, workspaceId, kind, referenceNumber);
         return row ? this.normalizePersistedAsset(mapAssetRow(row)) : null;
     }
+    updateDocumentContentMetadataIfVersion(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const assetId = normalizeId(input.assetId);
+        const expectedVersion = Math.max(0, Math.floor(Number(input.expectedVersion)));
+        const result = this.db.prepare(`
+            UPDATE workspace_assets
+            SET content_sha256 = ?,
+                size_bytes = ?,
+                mime_type = ?,
+                version = ?,
+                is_latest = 1,
+                scan_status = ?,
+                scan_engine = ?,
+                scan_details = ?,
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+              AND kind = 'document' AND deleted_at IS NULL AND COALESCE(version, 0) = ?
+        `).run(normalizeId(input.contentSha256), Math.max(0, Math.floor(Number(input.sizeBytes || 0))), normalizeId(input.mimeType, 'text/markdown'), expectedVersion + 1, normalizeId(input.scanStatus, 'clean'), normalizeNullable(input.scanEngine), normalizeNullable(input.scanDetails), normalizeId(input.updatedAt), this.tenantId, workspaceId, assetId, expectedVersion);
+        if (Number(result?.changes || 0) !== 1)
+            return null;
+        return this.get(assetId, workspaceId);
+    }
+    /**
+     * Force an existing readable asset to a cloud-authoritative D-/I- number.
+     * If another local asset already owns that number, reassign the conflict
+     * to the next free number so durable nested attachment links can install.
+     */
+    adoptReadableReferenceNumber(workspaceIdRaw, assetIdRaw, referenceNumberRaw) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const assetId = normalizeId(assetIdRaw);
+        const desired = normalizeReferenceNumber(referenceNumberRaw);
+        const asset = this.get(assetId, workspaceId);
+        if (!asset) {
+            throw new Error(`Cannot adopt reference number for missing asset ${assetId}`);
+        }
+        if (!usesReadableAssetReference(asset.kind) || !desired) {
+            return asset;
+        }
+        if (asset.referenceNumber === desired) {
+            return asset;
+        }
+        const conflicting = this.getByKindAndReferenceNumber(workspaceId, asset.kind, desired);
+        if (conflicting && conflicting.assetId !== assetId) {
+            // Conflict holds `desired`, so max+1 is always free and never equal to it.
+            const reassigned = this.findNextAvailableReadableAssetReferenceNumber(workspaceId, asset.kind);
+            this.upsertAsset({
+                assetId: conflicting.assetId,
+                workspaceId,
+                kind: conflicting.kind,
+                logicalName: conflicting.logicalName,
+                originalFilename: conflicting.originalFilename,
+                mimeType: conflicting.mimeType,
+                storageProvider: conflicting.storageProvider,
+                storageKey: conflicting.storageKey,
+                contentSha256: conflicting.contentSha256,
+                sizeBytes: conflicting.sizeBytes,
+                documentId: conflicting.documentId,
+                referenceNumber: reassigned,
+                version: conflicting.version,
+                isLatest: conflicting.isLatest,
+                scanStatus: conflicting.scanStatus,
+                scanEngine: conflicting.scanEngine,
+                scanDetails: conflicting.scanDetails,
+                createdByUserId: conflicting.createdByUserId,
+                createdAt: conflicting.createdAt,
+                updatedAt: conflicting.updatedAt,
+                deletedAt: conflicting.deletedAt,
+                purgeAfter: conflicting.purgeAfter,
+                allowReferenceNumberReassignment: true,
+            });
+        }
+        return this.upsertAsset({
+            assetId: asset.assetId,
+            workspaceId,
+            kind: asset.kind,
+            logicalName: asset.logicalName,
+            originalFilename: asset.originalFilename,
+            mimeType: asset.mimeType,
+            storageProvider: asset.storageProvider,
+            storageKey: asset.storageKey,
+            contentSha256: asset.contentSha256,
+            sizeBytes: asset.sizeBytes,
+            documentId: asset.documentId,
+            referenceNumber: desired,
+            version: asset.version,
+            isLatest: asset.isLatest,
+            scanStatus: asset.scanStatus,
+            scanEngine: asset.scanEngine,
+            scanDetails: asset.scanDetails,
+            createdByUserId: asset.createdByUserId,
+            createdAt: asset.createdAt,
+            updatedAt: asset.updatedAt,
+            deletedAt: asset.deletedAt,
+            purgeAfter: asset.purgeAfter,
+            allowReferenceNumberReassignment: true,
+        });
+    }
     upsertAsset(input) {
         const normalizedKind = normalizeCanonicalAssetKind({
             kind: input.kind,
@@ -360,6 +654,22 @@ export class WorkspaceAssetStore {
         }
         return all;
     }
+    listDocumentsByWorkspace(workspaceIdRaw, options) {
+        return this.listAllByWorkspace(workspaceIdRaw, {
+            ...options,
+            kind: 'document',
+        }).flatMap((entry) => {
+            const document = toWorkspaceDocumentEntry(entry);
+            return document ? [document] : [];
+        });
+    }
+    listAllNormalizedByWorkspace(workspaceIdRaw, options) {
+        const normalized = this.listAllByWorkspace(workspaceIdRaw, options)
+            .map((entry) => this.normalizePersistedAsset(entry));
+        return options?.kind
+            ? normalized.filter((entry) => entry.kind === options.kind)
+            : normalized;
+    }
     listAll(options) {
         const includeDeleted = options?.includeDeleted === true;
         const kind = options?.kind ? String(options.kind) : '';
@@ -416,27 +726,46 @@ export class WorkspaceAssetStore {
         if (!assetId)
             return null;
         const nowIso = normalizeId(deletedAt, new Date().toISOString());
-        this.db.prepare(`
-            UPDATE workspace_assets
-            SET deleted_at = ?, purge_after = ?, updated_at = ?
-            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
-        `).run(nowIso, normalizeNullable(purgeAfter), nowIso, this.tenantId, workspaceId, assetId);
-        return this.get(assetId, workspaceId);
+        return this.runDurableAssetMutation(workspaceId, assetId, () => {
+            this.db.prepare(`
+                UPDATE workspace_assets
+                SET deleted_at = ?, purge_after = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+            `).run(nowIso, normalizeNullable(purgeAfter), nowIso, this.tenantId, workspaceId, assetId);
+            return this.get(assetId, workspaceId);
+        });
+    }
+    restoreDeleted(assetIdRaw, workspaceIdRaw, restoredUpdatedAt) {
+        const assetId = normalizeId(assetIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!assetId)
+            return null;
+        return this.runDurableAssetMutation(workspaceId, assetId, () => {
+            const updatedAt = normalizeId(restoredUpdatedAt, new Date().toISOString());
+            this.db.prepare(`
+                UPDATE workspace_assets
+                SET deleted_at = NULL, purge_after = NULL, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+            `).run(updatedAt, this.tenantId, workspaceId, assetId);
+            return this.get(assetId, workspaceId);
+        });
     }
     remove(assetIdRaw, workspaceIdRaw) {
         const assetId = normalizeId(assetIdRaw);
         const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
         if (!assetId)
             return false;
-        this.db.prepare(`
-            DELETE FROM workspace_asset_links
-            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
-        `).run(this.tenantId, workspaceId, assetId);
-        const result = this.db.prepare(`
-            DELETE FROM workspace_assets
-            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
-        `).run(this.tenantId, workspaceId, assetId);
-        return Number(result?.changes || 0) > 0;
+        return this.runDurableAssetMutation(workspaceId, assetId, () => {
+            this.db.prepare(`
+                DELETE FROM workspace_asset_links
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+            `).run(this.tenantId, workspaceId, assetId);
+            const result = this.db.prepare(`
+                DELETE FROM workspace_assets
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+            `).run(this.tenantId, workspaceId, assetId);
+            return Number(result?.changes || 0) > 0;
+        });
     }
     upsertLink(input) {
         const workspaceId = normalizeWorkspaceId(input.workspaceId);
@@ -496,6 +825,12 @@ export class WorkspaceAssetStore {
         return this.listLinksForAsset(assetId, workspaceId, { includeDeleted: true })
             .find((entry) => entry.targetType === targetType && entry.targetId === targetId && entry.role === role);
     }
+    upsertLegacySyncLink(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const targetType = normalizeId(input.targetType, input.taskId ? 'task' : 'task');
+        const targetId = normalizeId(input.targetId, input.taskId || '');
+        return this.runLegacySyncLinkMutation(workspaceId, targetType, targetId, null, () => this.upsertLink(input));
+    }
     listLinksForTask(taskIdRaw, workspaceIdRaw, options) {
         return this.listLinksForTarget('task', taskIdRaw, workspaceIdRaw, options);
     }
@@ -536,15 +871,51 @@ export class WorkspaceAssetStore {
         if (!assetId)
             return [];
         const includeDeleted = options?.includeDeleted === true;
-        const rows = this.db.prepare(`
-            SELECT *
-            FROM workspace_asset_links
-            WHERE tenant_id = ?
-              AND workspace_id = ?
-              AND asset_id = ?
-              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
-            ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, task_id ASC
-        `).all(this.tenantId, workspaceId, assetId);
+        const rows = this.supportsTargetType()
+            ? this.db.prepare(`
+                SELECT *
+                FROM workspace_asset_links
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                  AND asset_id = ?
+                  ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+                ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC,
+                         task_id ASC, role ASC, target_type ASC
+            `).all(this.tenantId, workspaceId, assetId)
+            : this.db.prepare(`
+                SELECT *
+                FROM workspace_asset_links
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                  AND asset_id = ?
+                  ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+                ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC,
+                         task_id ASC, role ASC
+            `).all(this.tenantId, workspaceId, assetId);
+        return rows.map(mapLinkRow);
+    }
+    listLinksForWorkspace(workspaceIdRaw, options) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const includeDeleted = options?.includeDeleted === true;
+        const rows = this.supportsTargetType()
+            ? this.db.prepare(`
+                SELECT *
+                FROM workspace_asset_links
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                  ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+                ORDER BY asset_id ASC, COALESCE(sort_order, 2147483647) ASC, created_at ASC,
+                         task_id ASC, role ASC, target_type ASC
+            `).all(this.tenantId, workspaceId)
+            : this.db.prepare(`
+                SELECT *
+                FROM workspace_asset_links
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                  ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+                ORDER BY asset_id ASC, COALESCE(sort_order, 2147483647) ASC, created_at ASC,
+                         task_id ASC, role ASC
+            `).all(this.tenantId, workspaceId);
         return rows.map(mapLinkRow);
     }
     deleteLink(input) {
@@ -555,6 +926,18 @@ export class WorkspaceAssetStore {
         const role = normalizeId(input.role);
         if (!assetId || !targetId || !role)
             return false;
+        if (targetType === 'initiative' && input.allowDurableInitiativeWrite !== true) {
+            return this.runDurableAssetMutation(workspaceId, assetId, () => this.deleteLink({
+                ...input,
+                allowDurableInitiativeWrite: true,
+            }));
+        }
+        if (targetType === 'workstream' && input.allowDurableWorkstreamWrite !== true) {
+            return this.runDurableAssetMutation(workspaceId, assetId, () => this.deleteLink({
+                ...input,
+                allowDurableWorkstreamWrite: true,
+            }));
+        }
         if (input.hardDelete) {
             const result = this.supportsTargetType()
                 ? this.db.prepare(`
@@ -581,4 +964,14 @@ export class WorkspaceAssetStore {
             `).run(nowIso, nowIso, this.tenantId, workspaceId, assetId, targetId, role);
         return Number(result?.changes || 0) > 0;
     }
+    deleteLegacySyncLink(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const targetType = normalizeId(input.targetType, input.taskId ? 'task' : 'task');
+        const targetId = normalizeId(input.targetId, input.taskId || '');
+        return this.runLegacySyncLinkMutation(workspaceId, targetType, targetId, false, () => (this.deleteLink({
+            ...input,
+            allowDurableInitiativeWrite: targetType === 'initiative' ? true : input.allowDurableInitiativeWrite,
+            allowDurableWorkstreamWrite: targetType === 'workstream' ? true : input.allowDurableWorkstreamWrite,
+        })));
+    }
 }

package/dist/sync/aiProfileAvatarSyncPaths.d.ts

@@ -0,0 +1,14 @@
+export interface AiProfileAvatarPathSource {
+    avatarUrl?: unknown;
+    avatarSourceUrl?: unknown;
+    updatedAt?: unknown;
+    createdAt?: unknown;
+}
+export interface ReferencedAiProfileAvatarAssetMetadata {
+    updatedAt: string;
+    assetId?: string;
+    originalFilename: string;
+    mimeType: string;
+}
+export declare function isAiProfileAvatarAssetPath(value: string, workspaceId: string): boolean;
+export declare function listReferencedAiProfileAvatarAssetPaths(profiles: AiProfileAvatarPathSource[], workspaceId: string, normalizePath: (rawPath: string) => string | null): Map<string, ReferencedAiProfileAvatarAssetMetadata>;