@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/storage/workspaceAssetStore.test.js

@@ -0,0 +1,501 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { createDatabaseAdapter } from './createDatabaseAdapter.js';
+import { ensureDocumentReferenceSchema, ensureTaskAssetsSchema, ensureWorkspaceAssetsSchema } from '../migrations/taskSchemaMigrations.js';
+import { WorkspaceAssetStore } from './workspaceAssetStore.js';
+function makeStore() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-workspace-assets-'));
+    const dbPath = path.join(root, 'taskforce.db');
+    const db = createDatabaseAdapter({ sqliteDbPath: dbPath });
+    ensureTaskAssetsSchema(db);
+    ensureWorkspaceAssetsSchema(db);
+    ensureDocumentReferenceSchema(db);
+    const store = new WorkspaceAssetStore(db, 'default');
+    return {
+        root,
+        db,
+        store,
+        cleanup() {
+            db.close();
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    };
+}
+describe('WorkspaceAssetStore', () => {
+    const cleanups = [];
+    afterEach(() => {
+        while (cleanups.length > 0) {
+            const cleanup = cleanups.pop();
+            cleanup?.();
+        }
+    });
+    it('upserts and reads canonical assets by asset id', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        const created = ctx.store.upsertAsset({
+            assetId: 'asset-1',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            logicalName: 'Spec',
+            originalFilename: 'spec.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/asset-1-spec.md',
+            contentSha256: 'sha-123',
+            sizeBytes: 128,
+            documentId: 'doc-1',
+            version: 1,
+            createdByUserId: 'user-1',
+            scanStatus: 'clean'
+        });
+        expect(created.assetId).toBe('asset-1');
+        expect(created.workspaceId).toBe('workspace-1');
+        expect(created.kind).toBe('document');
+        expect(created.storageKey).toContain('workspaces/workspace-1/assets/documents');
+        expect(created.referenceNumber).toBe(1);
+        const fetched = ctx.store.get('asset-1', 'workspace-1');
+        expect(fetched).toMatchObject({
+            assetId: 'asset-1',
+            documentId: 'doc-1',
+            version: 1,
+            isLatest: true,
+            referenceNumber: 1
+        });
+    });
+    it('assigns sequential document reference numbers per workspace', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        const first = ctx.store.upsertAsset({
+            assetId: 'asset-doc-1',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'alpha.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-1-alpha.md',
+            contentSha256: 'sha-alpha',
+            sizeBytes: 10
+        });
+        const second = ctx.store.upsertAsset({
+            assetId: 'asset-doc-2',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'beta.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-2-beta.md',
+            contentSha256: 'sha-beta',
+            sizeBytes: 20
+        });
+        const otherWorkspace = ctx.store.upsertAsset({
+            assetId: 'asset-doc-3',
+            workspaceId: 'workspace-2',
+            kind: 'document',
+            originalFilename: 'gamma.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-2/assets/documents/asset-doc-3-gamma.md',
+            contentSha256: 'sha-gamma',
+            sizeBytes: 30
+        });
+        expect(first.referenceNumber).toBe(1);
+        expect(second.referenceNumber).toBe(2);
+        expect(otherWorkspace.referenceNumber).toBe(1);
+    });
+    it('assigns sequential image reference numbers per workspace independently from documents', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        const firstImage = ctx.store.upsertAsset({
+            assetId: 'asset-image-1',
+            workspaceId: 'workspace-1',
+            kind: 'image',
+            originalFilename: 'alpha.png',
+            mimeType: 'image/png',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/images/asset-image-1-alpha.png',
+            contentSha256: 'sha-image-alpha',
+            sizeBytes: 10
+        });
+        const document = ctx.store.upsertAsset({
+            assetId: 'asset-doc-1',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'alpha.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-1-alpha.md',
+            contentSha256: 'sha-doc-alpha',
+            sizeBytes: 20
+        });
+        const secondImage = ctx.store.upsertAsset({
+            assetId: 'asset-image-2',
+            workspaceId: 'workspace-1',
+            kind: 'image',
+            originalFilename: 'beta.png',
+            mimeType: 'image/png',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/images/asset-image-2-beta.png',
+            contentSha256: 'sha-image-beta',
+            sizeBytes: 30
+        });
+        expect(firstImage.referenceNumber).toBe(1);
+        expect(document.referenceNumber).toBe(1);
+        expect(secondImage.referenceNumber).toBe(2);
+    });
+    it('preserves an existing readable asset reference number during normal upserts', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        const created = ctx.store.upsertAsset({
+            assetId: 'asset-doc-stable-1',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'alpha.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-stable-1-alpha.md',
+            contentSha256: 'sha-alpha',
+            sizeBytes: 10,
+            referenceNumber: 5
+        });
+        const updated = ctx.store.upsertAsset({
+            assetId: 'asset-doc-stable-1',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'alpha.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-stable-1-alpha.md',
+            contentSha256: 'sha-alpha-2',
+            sizeBytes: 12,
+            referenceNumber: 11
+        });
+        expect(created.referenceNumber).toBe(5);
+        expect(updated.referenceNumber).toBe(5);
+    });
+    it('allows readable asset reference reassignment only when explicitly requested', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        ctx.store.upsertAsset({
+            assetId: 'asset-image-stable-1',
+            workspaceId: 'workspace-1',
+            kind: 'image',
+            originalFilename: 'alpha.png',
+            mimeType: 'image/png',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/images/asset-image-stable-1-alpha.png',
+            contentSha256: 'sha-image-alpha',
+            sizeBytes: 10,
+            referenceNumber: 3
+        });
+        const repaired = ctx.store.upsertAsset({
+            assetId: 'asset-image-stable-1',
+            workspaceId: 'workspace-1',
+            kind: 'image',
+            originalFilename: 'alpha.png',
+            mimeType: 'image/png',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/images/asset-image-stable-1-alpha.png',
+            contentSha256: 'sha-image-beta',
+            sizeBytes: 10,
+            referenceNumber: 7,
+            allowReferenceNumberReassignment: true
+        });
+        expect(repaired.referenceNumber).toBe(7);
+    });
+    it('skips stale sequence values when allocating readable asset references', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        ctx.store.upsertAsset({
+            assetId: 'asset-doc-existing',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'existing.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/existing.md',
+            contentSha256: 'sha-existing',
+            sizeBytes: 10,
+            referenceNumber: 1
+        });
+        ctx.db.prepare(`
+            INSERT INTO workspace_document_reference_sequences (tenant_id, workspace_id, next_reference_number)
+            VALUES ('default', 'workspace-1', 0)
+            ON CONFLICT (tenant_id, workspace_id) DO UPDATE SET next_reference_number = 0
+        `).run();
+        const created = ctx.store.upsertAsset({
+            assetId: 'asset-doc-new',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'new.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/new.md',
+            contentSha256: 'sha-new',
+            sizeBytes: 10
+        });
+        expect(created.referenceNumber).toBe(2);
+    });
+    it('retries with the next available readable reference when the database raises a reference collision', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        ctx.store.upsertAsset({
+            assetId: 'asset-doc-existing',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'existing.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/existing.md',
+            contentSha256: 'sha-existing',
+            sizeBytes: 10,
+            referenceNumber: 7
+        });
+        const originalPrepare = ctx.db.prepare.bind(ctx.db);
+        let forcedCollision = false;
+        vi.spyOn(ctx.db, 'prepare').mockImplementation((sql) => {
+            const statement = originalPrepare(sql);
+            if (!sql.includes('INSERT INTO workspace_assets')) {
+                return statement;
+            }
+            return {
+                ...statement,
+                run: (...args) => {
+                    const referenceNumberArg = args[12];
+                    if (!forcedCollision && referenceNumberArg === 8) {
+                        forcedCollision = true;
+                        throw new Error('UNIQUE constraint failed: workspace_assets.tenant_id, workspace_assets.workspace_id, workspace_assets.kind, workspace_assets.reference_number');
+                    }
+                    return statement.run(...args);
+                }
+            };
+        });
+        const created = ctx.store.upsertAsset({
+            assetId: 'asset-doc-new',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'new.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/new.md',
+            contentSha256: 'sha-new',
+            sizeBytes: 10,
+            referenceNumber: 8
+        });
+        expect(created.referenceNumber).toBe(8 + 1);
+    });
+    it('migrates old cross-kind asset reference indexes before backfilling image references', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-workspace-assets-migrate-'));
+        const dbPath = path.join(root, 'taskforce.db');
+        const db = createDatabaseAdapter({ sqliteDbPath: dbPath });
+        cleanups.push(() => {
+            db.close();
+            fs.rmSync(root, { recursive: true, force: true });
+        });
+        ensureTaskAssetsSchema(db);
+        ensureWorkspaceAssetsSchema(db);
+        db.exec(`ALTER TABLE workspace_assets ADD COLUMN reference_number INTEGER`);
+        db.exec(`
+            CREATE TABLE workspace_document_reference_sequences (
+                tenant_id TEXT NOT NULL DEFAULT 'default',
+                workspace_id TEXT NOT NULL DEFAULT 'default',
+                next_reference_number INTEGER NOT NULL DEFAULT 0,
+                PRIMARY KEY (tenant_id, workspace_id)
+            );
+            CREATE UNIQUE INDEX idx_workspace_assets_workspace_reference
+            ON workspace_assets(tenant_id, workspace_id, reference_number);
+        `);
+        const insertAsset = db.prepare(`
+            INSERT INTO workspace_assets (
+                asset_id,
+                tenant_id,
+                workspace_id,
+                kind,
+                logical_name,
+                original_filename,
+                mime_type,
+                storage_provider,
+                storage_key,
+                content_sha256,
+                size_bytes,
+                document_id,
+                version,
+                is_latest,
+                scan_status,
+                scan_engine,
+                scan_details,
+                created_by_user_id,
+                created_at,
+                updated_at,
+                deleted_at,
+                purge_after,
+                reference_number
+            ) VALUES (?, 'default', 'workspace-1', ?, NULL, ?, ?, 'local', ?, ?, ?, NULL, 1, 1, 'clean', NULL, NULL, NULL, ?, ?, NULL, NULL, ?)
+        `);
+        insertAsset.run('asset-doc-1', 'document', 'doc-1.md', 'text/markdown', 'workspaces/workspace-1/assets/documents/asset-doc-1-doc-1.md', 'sha-doc-1', 10, '2026-03-25T12:00:00.000Z', '2026-03-25T12:00:00.000Z', 1);
+        insertAsset.run('asset-doc-2', 'document', 'doc-2.md', 'text/markdown', 'workspaces/workspace-1/assets/documents/asset-doc-2-doc-2.md', 'sha-doc-2', 20, '2026-03-25T12:01:00.000Z', '2026-03-25T12:01:00.000Z', 2);
+        insertAsset.run('asset-image-1', 'image', 'image-1.png', 'image/png', 'workspaces/workspace-1/assets/images/asset-image-1-image-1.png', 'sha-image-1', 30, '2026-03-25T12:02:00.000Z', '2026-03-25T12:02:00.000Z', null);
+        insertAsset.run('asset-image-2', 'image', 'image-2.png', 'image/png', 'workspaces/workspace-1/assets/images/asset-image-2-image-2.png', 'sha-image-2', 40, '2026-03-25T12:03:00.000Z', '2026-03-25T12:03:00.000Z', null);
+        expect(() => ensureDocumentReferenceSchema(db)).not.toThrow();
+        const migrated = db.prepare(`
+            SELECT kind, reference_number
+            FROM workspace_assets
+            WHERE tenant_id = 'default' AND workspace_id = 'workspace-1'
+            ORDER BY kind ASC, asset_id ASC
+        `).all();
+        expect(migrated).toEqual([
+            { kind: 'document', reference_number: 1 },
+            { kind: 'document', reference_number: 2 },
+            { kind: 'image', reference_number: 1 },
+            { kind: 'image', reference_number: 2 }
+        ]);
+    });
+    it('lists workspace assets and excludes deleted rows by default', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        ctx.store.upsertAsset({
+            assetId: 'asset-a',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'a.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/asset-a-a.md',
+            contentSha256: 'sha-a',
+            sizeBytes: 10
+        });
+        ctx.store.upsertAsset({
+            assetId: 'asset-b',
+            workspaceId: 'workspace-1',
+            kind: 'image',
+            originalFilename: 'b.png',
+            mimeType: 'image/png',
+            storageProvider: 'r2',
+            storageKey: 'workspaces/workspace-1/assets/images/asset-b-b.png',
+            contentSha256: 'sha-b',
+            sizeBytes: 20
+        });
+        ctx.store.markDeleted('asset-b', 'workspace-1', '2026-03-17T00:00:00.000Z', '2026-03-24T00:00:00.000Z');
+        const active = ctx.store.listByWorkspace('workspace-1');
+        expect(active.map((entry) => entry.assetId)).toEqual(['asset-a']);
+        const all = ctx.store.listByWorkspace('workspace-1', { includeDeleted: true });
+        expect(all.map((entry) => entry.assetId).sort()).toEqual(['asset-a', 'asset-b']);
+    });
+    it('creates, lists, and soft-deletes task links separately from asset identity', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        ctx.store.upsertAsset({
+            assetId: 'asset-link-1',
+            workspaceId: 'workspace-1',
+            kind: 'file',
+            originalFilename: 'brief.pdf',
+            mimeType: 'application/pdf',
+            storageProvider: 'r2',
+            storageKey: 'workspaces/workspace-1/assets/files/asset-link-1-brief.pdf',
+            contentSha256: 'sha-link',
+            sizeBytes: 55
+        });
+        ctx.store.upsertLink({
+            workspaceId: 'workspace-1',
+            assetId: 'asset-link-1',
+            taskId: 'task-1',
+            role: 'attachment',
+            sortOrder: 2
+        });
+        ctx.store.upsertLink({
+            workspaceId: 'workspace-1',
+            assetId: 'asset-link-1',
+            taskId: 'task-2',
+            role: 'reference',
+            sortOrder: 1
+        });
+        const taskLinks = ctx.store.listLinksForTask('task-1', 'workspace-1');
+        expect(taskLinks).toHaveLength(1);
+        expect(taskLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'attachment' });
+        const assetLinks = ctx.store.listLinksForAsset('asset-link-1', 'workspace-1');
+        expect(assetLinks).toHaveLength(2);
+        expect(assetLinks.map((entry) => entry.taskId)).toEqual(['task-2', 'task-1']);
+        expect(ctx.store.deleteLink({
+            workspaceId: 'workspace-1',
+            assetId: 'asset-link-1',
+            taskId: 'task-1',
+            role: 'attachment'
+        })).toBe(true);
+        expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toHaveLength(0);
+        expect(ctx.store.listLinksForTask('task-1', 'workspace-1', { includeDeleted: true })).toHaveLength(1);
+    });
+    it('resolves legacy path-keyed writes through a stable canonical asset id', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        const created = ctx.store.upsertAsset({
+            assetId: 'asset-legacy-1',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'notes.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'task-data/task-1/attachments/notes.md',
+            contentSha256: 'sha-v1',
+            sizeBytes: 12,
+            documentId: 'doc-legacy-1',
+            version: 1
+        });
+        const samePath = ctx.store.getByStorageKey('task-data/task-1/attachments/notes.md', 'workspace-1');
+        expect(samePath).toMatchObject({
+            assetId: created.assetId,
+            documentId: 'doc-legacy-1',
+            version: 1
+        });
+        ctx.store.upsertAsset({
+            assetId: created.assetId,
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            originalFilename: 'notes.md',
+            mimeType: 'text/markdown',
+            storageProvider: 'local',
+            storageKey: 'task-data/task-1/attachments/notes.md',
+            contentSha256: 'sha-v2',
+            sizeBytes: 24,
+            documentId: 'doc-legacy-1',
+            version: 2
+        });
+        const updated = ctx.store.getByStorageKey('task-data/task-1/attachments/notes.md', 'workspace-1');
+        expect(updated).toMatchObject({
+            assetId: created.assetId,
+            documentId: 'doc-legacy-1',
+            version: 2,
+            contentSha256: 'sha-v2',
+            sizeBytes: 24
+        });
+    });
+    it('normalizes invalid document metadata for txt files into plain files', () => {
+        const ctx = makeStore();
+        cleanups.push(() => ctx.cleanup());
+        const created = ctx.store.upsertAsset({
+            assetId: 'asset-invalid-doc-1',
+            workspaceId: 'workspace-1',
+            kind: 'document',
+            logicalName: 'diagnostic.txt',
+            originalFilename: 'diagnostic.txt',
+            mimeType: 'text/plain',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/documents/asset-invalid-doc-1-diagnostic.txt',
+            contentSha256: 'sha-invalid-doc-1',
+            sizeBytes: 42,
+            documentId: 'doc-invalid',
+            version: 1
+        });
+        expect(created.kind).toBe('file');
+        expect(created.referenceNumber).toBeNull();
+        expect(created.documentId).toBeNull();
+        expect(created.version).toBeNull();
+        const fetched = ctx.store.get('asset-invalid-doc-1', 'workspace-1');
+        expect(fetched).toMatchObject({
+            kind: 'file',
+            referenceNumber: null,
+            documentId: null,
+            version: null
+        });
+    });
+});

package/dist/sync/cloudSyncApi.d.ts

@@ -1,4 +1,4 @@
-import type { WorkspaceSyncChange } from './workspaceSyncModel';
+import type { WorkspaceSyncChange, WorkspaceSyncWorkspaceMemberSnapshot } from './workspaceSyncModel';
 export interface SyncHttpResult<T = unknown> {
     ok: boolean;
     status: number;
@@ -19,15 +19,18 @@ export declare function pullWorkspaceChanges(resolveCloudAuthUrl: (path: string)
     workspaceId: string;
     cursor?: string | null;
     limit: number;
+    repairMode?: boolean;
 }): Promise<SyncHttpResult<{
     changes?: WorkspaceSyncChange[];
     nextCursor?: string | null;
     hasMore?: boolean;
+    workspaceMembers?: WorkspaceSyncWorkspaceMemberSnapshot[];
 }>>;
 export declare function pushWorkspaceChanges(resolveCloudAuthUrl: (path: string) => string, input: {
     workspaceId: string;
     idempotencyKey: string;
     changes: WorkspaceSyncChange[];
+    repairMode?: boolean;
 }): Promise<SyncHttpResult>;
 export declare function bootstrapPushWorkspaceSnapshot(resolveCloudAuthUrl: (path: string) => string, input: {
     workspaceId: string;
@@ -38,10 +41,38 @@ export declare function bootstrapPushWorkspaceSnapshot(resolveCloudAuthUrl: (pat
         path: string;
         updatedAt: string;
         content: string;
+        assetId?: string;
+        documentId?: string | null;
+        version?: number | null;
+        taskId?: string | null;
+        logicalName?: string | null;
+        caption?: string | null;
+        originalFilename?: string | null;
+        linkRole?: 'attachment' | 'reference';
+    }>;
+    assets?: Array<{
+        path: string;
+        updatedAt: string;
+        contentBase64: string;
+        assetId?: string;
+        kind: 'image' | 'file';
+        mimeType: string;
+        taskId?: string | null;
+        logicalName?: string | null;
+        caption?: string | null;
+        originalFilename?: string | null;
+        linkRole?: 'attachment' | 'image' | 'reference';
     }>;
 }): Promise<SyncHttpResult>;
-export declare function applyLocalWorkspaceChanges(workspaceId: string, changes: WorkspaceSyncChange[]): Promise<{
+export declare function applyLocalWorkspaceChanges(workspaceId: string, changes: WorkspaceSyncChange[], options?: {
+    workspaceMembers?: WorkspaceSyncWorkspaceMemberSnapshot[];
+    bootstrapSnapshot?: {
+        currentAnnotatedAttachmentSessionIds?: string[];
+    };
+    repairMode?: boolean;
+}): Promise<{
     ok: boolean;
+    status: number;
     data: unknown;
     failures: string[];
 }>;

package/dist/sync/cloudSyncApi.js

@@ -79,6 +79,8 @@ export async function pullWorkspaceChanges(resolveCloudAuthUrl, input) {
     const params = new URLSearchParams({ limit: String(input.limit), workspaceId: input.workspaceId });
     if (input.cursor)
         params.set('cursor', input.cursor);
+    if (input.repairMode === true)
+        params.set('repair', '1');
     const baseUrl = resolveCloudAuthUrl('/api/taskforce/sync/workspace/pull');
     const separator = baseUrl.includes('?') ? '&' : '?';
     return requestJson(fetch(`${baseUrl}${separator}${params.toString()}`, {
@@ -91,7 +93,10 @@ export async function pushWorkspaceChanges(resolveCloudAuthUrl, input) {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         credentials: 'include',
-        body: JSON.stringify(input)
+        body: JSON.stringify({
+            ...input,
+            ...(input.repairMode === true ? { repair: true } : {})
+        })
     }));
 }
 export async function bootstrapPushWorkspaceSnapshot(resolveCloudAuthUrl, input) {
@@ -102,18 +107,21 @@ export async function bootstrapPushWorkspaceSnapshot(resolveCloudAuthUrl, input)
         body: JSON.stringify(input)
     }));
 }
-export async function applyLocalWorkspaceChanges(workspaceId, changes) {
-    const applyPayload = JSON.stringify({ workspaceId, changes });
-    const resolveApplyLocalEndpoint = () => {
-        if (typeof window === 'undefined')
-            return '/api/taskforce/sync/workspace/apply-local';
-        const pathname = String(window.location?.pathname || '/');
-        if (pathname === '/taskforce' || pathname.startsWith('/taskforce/')) {
-            return '/taskforce/api/taskforce/sync/workspace/apply-local';
-        }
-        return '/api/taskforce/sync/workspace/apply-local';
-    };
-    const applyEndpoint = resolveApplyLocalEndpoint();
+export async function applyLocalWorkspaceChanges(workspaceId, changes, options) {
+    const applyPayload = JSON.stringify({
+        workspaceId,
+        changes,
+        workspaceMembers: Array.isArray(options?.workspaceMembers) ? options.workspaceMembers : undefined,
+        ...(options?.repairMode === true ? { repair: true } : {}),
+        bootstrapSnapshot: options?.bootstrapSnapshot
+            ? {
+                currentAnnotatedAttachmentSessionIds: Array.isArray(options.bootstrapSnapshot.currentAnnotatedAttachmentSessionIds)
+                    ? options.bootstrapSnapshot.currentAnnotatedAttachmentSessionIds
+                    : []
+            }
+            : undefined
+    });
+    const applyEndpoint = '/api/taskforce/sync/workspace/apply-local';
     const failures = [];
     try {
         const response = await fetch(applyEndpoint, {
@@ -127,12 +135,26 @@ export async function applyLocalWorkspaceChanges(workspaceId, changes) {
         });
         if (response.ok) {
             const data = await response.json().catch(() => ({}));
-            return { ok: true, data, failures };
+            return { ok: true, status: response.status, data, failures };
+        }
+        const rawText = await response.text().catch(() => '');
+        let data = {};
+        if (rawText) {
+            try {
+                data = JSON.parse(rawText);
+            }
+            catch {
+                data = { error: rawText.slice(0, 400) };
+            }
+        }
+        else if (response.statusText) {
+            data = { error: `${response.status} ${response.statusText}` };
         }
         failures.push(`${applyEndpoint}:${response.status}`);
+        return { ok: false, status: response.status, data, failures };
     }
     catch {
         failures.push(`${applyEndpoint}:network`);
     }
-    return { ok: false, data: {}, failures };
+    return { ok: false, status: 0, data: {}, failures };
 }