@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/hooks/useWorkspaceSyncController.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/useWorkspaceSyncController.test.js

@@ -1,192 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { act, renderHook } from '@testing-library/react';
-import { useWorkspaceSyncController } from './useWorkspaceSyncController';
-const makeInput = (overrides = {}) => ({
-    currentWorkspaceId: 'ws-test',
-    setWorkspaceCloudSyncEnabled: vi.fn(),
-    setWorkspaceSyncPhase: vi.fn(),
-    setWorkspaceSyncSetupIntent: vi.fn(),
-    setWorkspaceLastPullAt: vi.fn(),
-    setWorkspaceLastPushAt: vi.fn(),
-    setWorkspaceLastErrorMessage: vi.fn(),
-    ...overrides
-});
-describe('useWorkspaceSyncController', () => {
-    afterEach(() => {
-        localStorage.clear();
-        vi.unstubAllGlobals();
-        vi.clearAllMocks();
-    });
-    it('acquires and releases a workspace sync lease', async () => {
-        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
-        let acquired = false;
-        await act(async () => {
-            acquired = await result.current.acquireWorkspaceSyncLease('ws-test', 'pull');
-        });
-        expect(acquired).toBe(true);
-        expect(result.current.readWorkspaceSyncLease('ws-test')?.operation).toBe('pull');
-        act(() => {
-            result.current.releaseWorkspaceSyncLease('ws-test');
-        });
-        expect(result.current.readWorkspaceSyncLease('ws-test')).toBeNull();
-    });
-    it('refuses a healthy competing workspace sync lease owner', async () => {
-        window.localStorage.setItem('taskforce.sync.lease.v1.ws-test', JSON.stringify({
-            ownerId: 'other-window',
-            workspaceId: 'ws-test',
-            operation: 'pull',
-            heartbeatAt: new Date().toISOString(),
-            expiresAt: new Date(Date.now() + 30_000).toISOString()
-        }));
-        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
-        let acquired = true;
-        await act(async () => {
-            acquired = await result.current.acquireWorkspaceSyncLease('ws-test', 'push');
-        });
-        expect(acquired).toBe(false);
-        expect(result.current.readWorkspaceSyncLease('ws-test')?.ownerId).toBe('other-window');
-    });
-    it('reclaims a stale workspace sync lease owner', async () => {
-        window.localStorage.setItem('taskforce.sync.lease.v1.ws-test', JSON.stringify({
-            ownerId: 'other-window',
-            workspaceId: 'ws-test',
-            operation: 'pull',
-            heartbeatAt: '2026-03-15T10:00:00.000Z',
-            expiresAt: '2026-03-15T10:00:01.000Z'
-        }));
-        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
-        let acquired = false;
-        await act(async () => {
-            acquired = await result.current.acquireWorkspaceSyncLease('ws-test', 'repair');
-        });
-        expect(acquired).toBe(true);
-        expect(result.current.readWorkspaceSyncLease('ws-test')?.operation).toBe('repair');
-        expect(result.current.readWorkspaceSyncLease('ws-test')?.ownerId).not.toBe('other-window');
-    });
-    it('loads legacy workspace sync state through the v2 compat mapping', async () => {
-        vi.stubGlobal('fetch', vi.fn((url) => {
-            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        success: true,
-                        state: {
-                            cloudSyncEnabled: true,
-                            sourceOfTruth: 'cloud',
-                            onboardingCompleted: false,
-                            pullCursor: 'cursor-1'
-                        }
-                    })
-                });
-            }
-            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-        }));
-        const input = makeInput();
-        const { result } = renderHook(() => useWorkspaceSyncController(input));
-        await act(async () => {
-            await result.current.loadWorkspaceSyncState();
-        });
-        expect(input.setWorkspaceCloudSyncEnabled).toHaveBeenCalledWith(true);
-        expect(input.setWorkspaceSyncPhase).toHaveBeenCalledWith('attach-cloud');
-    });
-    it('clears local-only push baselines from remote ui-state patches', async () => {
-        const uiStatePosts = [];
-        vi.stubGlobal('fetch', vi.fn((url, init) => {
-            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        success: true,
-                        state: {
-                            version: 2,
-                            enabled: true,
-                            phase: 'active',
-                            pullCursor: 'cursor-1',
-                            pushBaseline: {
-                                taskIds: ['task-1'],
-                                taskWatermarks: [['task-1', 'x'.repeat(1024 * 1024)]],
-                                initiativeWatermarks: [],
-                                workstreamWatermarks: [],
-                                aiProfileWatermarks: [],
-                                documentWatermarks: [],
-                                assetWatermarks: [],
-                                documentReviewSessionWatermarks: [],
-                                documentReviewCommentWatermarks: [],
-                                annotatedAttachmentSessionWatermarks: [],
-                                taskEventWatermarks: [],
-                                taxonomyStateFingerprint: ''
-                            }
-                        }
-                    })
-                });
-            }
-            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
-                uiStatePosts.push(JSON.parse(String(init?.body || '{}')));
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-            }
-            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-        }));
-        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
-        await act(async () => {
-            await result.current.loadWorkspaceSyncState();
-            await result.current.persistWorkspaceSyncPatch({ lastPullAt: '2026-04-27T20:30:00.000Z' });
-        });
-        expect(result.current.readWorkspaceSyncStateSnapshot().pushBaseline?.taskWatermarks[0]?.[1]).toHaveLength(1024 * 1024);
-        expect(uiStatePosts).toHaveLength(1);
-        expect(uiStatePosts[0]?.patch?.lastPullAt).toBe('2026-04-27T20:30:00.000Z');
-        expect(uiStatePosts[0]?.patch?.pushBaseline).toBeNull();
-        expect(JSON.stringify(uiStatePosts[0])).not.toContain('xxxx');
-    });
-    it('persists attach-cloud phase when enabling sync for an existing cloud workspace', async () => {
-        const uiStatePosts = [];
-        vi.stubGlobal('fetch', vi.fn((url, init) => {
-            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
-                uiStatePosts.push(JSON.parse(String(init?.body || '{}')));
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-            }
-            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-        }));
-        const input = makeInput();
-        const { result } = renderHook(() => useWorkspaceSyncController(input));
-        let saveResult;
-        await act(async () => {
-            saveResult = await result.current.saveWorkspaceCloudSyncSettings({ enabled: true }, {
-                cloudAuthConfigured: true,
-                isAuthenticated: true,
-                ensureCloudWorkspaceReadyForSync: async () => ({ success: true, provisioned: false })
-            });
-        });
-        expect(saveResult).toEqual({ success: true });
-        expect(input.setWorkspaceCloudSyncEnabled).toHaveBeenCalledWith(true);
-        expect(input.setWorkspaceSyncPhase).toHaveBeenCalledWith('attach-cloud');
-        expect(uiStatePosts.some((entry) => entry?.patch?.version === 2
-            && entry?.patch?.enabled === true
-            && entry?.patch?.phase === 'attach-cloud'
-            && entry?.patch?.pullCursor === null)).toBe(true);
-    });
-    it('persists provision-local phase when enabling sync for a new cloud workspace', async () => {
-        const uiStatePosts = [];
-        vi.stubGlobal('fetch', vi.fn((url, init) => {
-            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
-                uiStatePosts.push(JSON.parse(String(init?.body || '{}')));
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-            }
-            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-        }));
-        const input = makeInput();
-        const { result } = renderHook(() => useWorkspaceSyncController(input));
-        let saveResult;
-        await act(async () => {
-            saveResult = await result.current.saveWorkspaceCloudSyncSettings({ enabled: true }, {
-                cloudAuthConfigured: true,
-                isAuthenticated: true,
-                ensureCloudWorkspaceReadyForSync: async () => ({ success: true, provisioned: true })
-            });
-        });
-        expect(saveResult).toEqual({ success: true });
-        expect(input.setWorkspaceSyncPhase).toHaveBeenCalledWith('provision-local');
-        expect(uiStatePosts.some((entry) => entry?.patch?.version === 2
-            && entry?.patch?.enabled === true
-            && entry?.patch?.phase === 'provision-local')).toBe(true);
-    });
-});

package/dist/hooks/workspace/useTaskforceApiRouting.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/workspace/useTaskforceApiRouting.test.js

@@ -1,77 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { createRef } from 'react';
-import { useTaskforceApiRouting } from './useTaskforceApiRouting';
-describe('useTaskforceApiRouting', () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('keeps local-only sync routes on the current origin in cloud runtime', async () => {
-        const fetchMock = vi.fn(async (input) => new Response(null, { status: 204 }));
-        vi.stubGlobal('fetch', fetchMock);
-        const currentWorkspaceIdRef = createRef();
-        currentWorkspaceIdRef.current = 'workspace-1';
-        renderHook(() => useTaskforceApiRouting({
-            currentWorkspaceIdRef,
-            runtimeMode: 'cloud',
-            resolveApiUrl: (path) => `https://cloud.example.com${path}`
-        }));
-        await window.fetch('/api/taskforce/sync/workspace/repair-startup', { method: 'POST' });
-        await window.fetch('/api/taskforce/sync/workspace/apply-local', { method: 'POST' });
-        await window.fetch('/api/taskforce/auth/runtime-config');
-        expect(fetchMock.mock.calls.map(([input]) => String(input))).toEqual([
-            '/api/taskforce/sync/workspace/repair-startup',
-            '/api/taskforce/sync/workspace/apply-local',
-            '/api/taskforce/auth/runtime-config'
-        ]);
-    });
-    it('still rewrites cloud-owned taskforce routes in cloud runtime', async () => {
-        const fetchMock = vi.fn(async (input) => new Response(null, { status: 204 }));
-        vi.stubGlobal('fetch', fetchMock);
-        const currentWorkspaceIdRef = createRef();
-        currentWorkspaceIdRef.current = 'workspace-1';
-        renderHook(() => useTaskforceApiRouting({
-            currentWorkspaceIdRef,
-            runtimeMode: 'cloud',
-            resolveApiUrl: (path) => `https://cloud.example.com${path}`
-        }));
-        await window.fetch('/api/taskforce/sync/workspace/pull?workspaceId=workspace-1');
-        expect(fetchMock).toHaveBeenCalledWith('https://cloud.example.com/api/taskforce/sync/workspace/pull?workspaceId=workspace-1', expect.objectContaining({
-            headers: expect.any(Headers)
-        }));
-    });
-    it('reads the injected workspace header from the live ref without waiting for rerender', async () => {
-        const fetchMock = vi.fn(async (_input, init) => new Response(null, { status: 204 }));
-        vi.stubGlobal('fetch', fetchMock);
-        const currentWorkspaceIdRef = createRef();
-        currentWorkspaceIdRef.current = 'workspace-1';
-        renderHook(() => useTaskforceApiRouting({
-            currentWorkspaceIdRef,
-            runtimeMode: 'cloud',
-            resolveApiUrl: (path) => `https://cloud.example.com${path}`
-        }));
-        currentWorkspaceIdRef.current = 'workspace-2';
-        await window.fetch('/api/taskforce/tasks');
-        const [, init] = fetchMock.mock.calls.at(-1);
-        const headers = init.headers;
-        expect(headers.get('x-taskforce-workspace-id')).toBe('workspace-2');
-        expect(headers.get('x-taskforce-workspace-authoritative')).toBe('1');
-    });
-    it('stops injecting the workspace header when the live ref resets to default', async () => {
-        const fetchMock = vi.fn(async (_input, init) => new Response(null, { status: 204 }));
-        vi.stubGlobal('fetch', fetchMock);
-        const currentWorkspaceIdRef = createRef();
-        currentWorkspaceIdRef.current = 'workspace-1';
-        renderHook(() => useTaskforceApiRouting({
-            currentWorkspaceIdRef,
-            runtimeMode: 'cloud',
-            resolveApiUrl: (path) => `https://cloud.example.com${path}`
-        }));
-        currentWorkspaceIdRef.current = 'default';
-        await window.fetch('/api/taskforce/tasks');
-        const [, init] = fetchMock.mock.calls.at(-1);
-        const headers = init.headers;
-        expect(headers.get('x-taskforce-workspace-id')).toBeNull();
-        expect(headers.get('x-taskforce-workspace-authoritative')).toBeNull();
-    });
-});

package/dist/hooks/workspace/workspaceLocalState.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/workspace/workspaceLocalState.test.js

@@ -1,59 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { persistRemoteUiState, resetRemoteUiStatePersistCache } from './workspaceLocalState';
-describe('persistRemoteUiState', () => {
-    afterEach(() => {
-        resetRemoteUiStatePersistCache();
-        vi.unstubAllGlobals();
-        vi.clearAllMocks();
-        vi.useRealTimers();
-    });
-    it('skips identical payloads after a successful persist', async () => {
-        const fetchMock = vi.fn(async () => ({
-            ok: true,
-            status: 200,
-            json: async () => ({ success: true })
-        }));
-        vi.stubGlobal('fetch', fetchMock);
-        const first = await persistRemoteUiState({
-            stateKey: 'app',
-            workspaceId: 'workspace-1',
-            patch: { activeWorkspaceModule: 'tasks' }
-        });
-        const second = await persistRemoteUiState({
-            stateKey: 'app',
-            workspaceId: 'workspace-1',
-            patch: { activeWorkspaceModule: 'tasks' }
-        });
-        expect(first.skipped).toBe(false);
-        expect(second).toEqual({ skipped: true, reason: 'unchanged' });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-    it('backs off identical failed payloads briefly before retrying', async () => {
-        vi.useFakeTimers();
-        const fetchMock = vi.fn(async () => {
-            throw new Error('gateway');
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const first = await persistRemoteUiState({
-            stateKey: 'layout',
-            workspaceId: 'workspace-1',
-            patch: { planningDrawerOpen: true }
-        });
-        const second = await persistRemoteUiState({
-            stateKey: 'layout',
-            workspaceId: 'workspace-1',
-            patch: { planningDrawerOpen: true }
-        });
-        expect(first.skipped).toBe(false);
-        expect(second).toEqual({ skipped: true, reason: 'cooldown' });
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        vi.advanceTimersByTime(5001);
-        const third = await persistRemoteUiState({
-            stateKey: 'layout',
-            workspaceId: 'workspace-1',
-            patch: { planningDrawerOpen: true }
-        });
-        expect(third.skipped).toBe(false);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/localization/localizationCatalogs.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/localization/localizationCatalogs.test.js

@@ -1,37 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { enUS } from './locales/en-US';
-import { es419 } from './locales/es-419';
-import { ptBR } from './locales/pt-BR';
-function collectLeafKeys(input, prefix = '') {
-    if (!input || typeof input !== 'object')
-        return [];
-    return Object.entries(input).flatMap(([key, value]) => {
-        const nextPrefix = prefix ? `${prefix}.${key}` : key;
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-            return collectLeafKeys(value, nextPrefix);
-        }
-        return [nextPrefix];
-    });
-}
-describe('Localization catalogs', () => {
-    it('keeps identical key coverage across locales', () => {
-        const enKeys = collectLeafKeys(enUS).sort();
-        const esKeys = collectLeafKeys(es419).sort();
-        const ptKeys = collectLeafKeys(ptBR).sort();
-        expect(esKeys).toEqual(enKeys);
-        expect(ptKeys).toEqual(enKeys);
-    });
-    it('avoids blank translations in non-default locales', () => {
-        const values = [es419, ptBR];
-        for (const catalog of values) {
-            for (const key of collectLeafKeys(catalog)) {
-                const segments = key.split('.');
-                let cursor = catalog;
-                for (const segment of segments)
-                    cursor = cursor?.[segment];
-                expect(typeof cursor).toBe('string');
-                expect(String(cursor).trim().length).toBeGreaterThan(0);
-            }
-        }
-    });
-});

package/dist/mcp/aiProfileBootstrap.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/mcp/aiProfileBootstrap.test.js

@@ -1,68 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AI_PROFILE_BOOTSTRAP_HEADER_NAMES, buildAiProfileBootstrapHeaders, buildResolveAiProfileInputFromBootstrap, parseAiProfileBootstrapHeaders, } from './aiProfileBootstrap';
-describe('aiProfileBootstrap', () => {
-    it('builds and parses bootstrap headers from a shared contract', () => {
-        const headers = buildAiProfileBootstrapHeaders({
-            aiProfileName: 'Automation Codex',
-            aiProfileToken: 'tfp_automation_codex',
-            aiProfileIcon: 'Code2',
-            aiProfileColor: '#10a37f',
-            aiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
-            aiProfileRole: 'Coding Agent',
-            aiProfileProvider: 'OpenAI',
-            aiProfileModel: 'Codex',
-            aiProfileSurfaceType: 'coding_tool',
-        });
-        expect(headers).toEqual({
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileName]: 'Automation Codex',
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileToken]: 'tfp_automation_codex',
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileIcon]: 'Code2',
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileColor]: '#10a37f',
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileDescription]: 'OpenAI Codex coding agent connected through MCP.',
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileRole]: 'Coding Agent',
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileProvider]: 'OpenAI',
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileModel]: 'Codex',
-            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileSurfaceType]: 'coding_tool',
-        });
-        expect(parseAiProfileBootstrapHeaders(headers)).toEqual({
-            aiProfileName: 'Automation Codex',
-            aiProfileToken: 'tfp_automation_codex',
-            aiProfileIcon: 'Code2',
-            aiProfileColor: '#10a37f',
-            aiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
-            aiProfileRole: 'Coding Agent',
-            aiProfileProvider: 'OpenAI',
-            aiProfileModel: 'Codex',
-            aiProfileSurfaceType: 'coding_tool',
-        });
-    });
-    it('builds resolve_profile input from bootstrap metadata', () => {
-        expect(buildResolveAiProfileInputFromBootstrap('workspace-1', {
-            aiProfileName: 'Automation Codex',
-            aiProfileToken: 'tfp_automation_codex',
-            aiProfileIcon: 'Code2',
-            aiProfileColor: '#10a37f',
-            aiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
-            aiProfileRole: 'Coding Agent',
-            aiProfileProvider: 'OpenAI',
-            aiProfileModel: 'Codex',
-            aiProfileSurfaceType: 'coding_tool',
-        })).toEqual({
-            workspaceId: 'workspace-1',
-            name: 'Automation Codex',
-            profileToken: 'tfp_automation_codex',
-            icon: 'Code2',
-            color: '#10a37f',
-            description: 'OpenAI Codex coding agent connected through MCP.',
-            role: 'Coding Agent',
-            provider: 'OpenAI',
-            model: 'Codex',
-            surfaceType: 'coding_tool',
-        });
-    });
-    it('returns null resolve input when no bootstrap name is present', () => {
-        expect(buildResolveAiProfileInputFromBootstrap('workspace-1', {
-            aiProfileToken: 'tfp_automation_codex',
-        })).toBeNull();
-    });
-});

package/dist/mcp/canonicalAssetHelpers.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/mcp/canonicalAssetHelpers.test.js

@@ -1,67 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { TaskforceCore } from '../core/Taskforce';
-import { createCanonicalAssetHelpers } from './canonicalAssetHelpers';
-function makeCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-mcp-canonical-assets-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    return {
-        projectRoot,
-        core,
-        cleanup: () => fs.rmSync(projectRoot, { recursive: true, force: true })
-    };
-}
-describe('MCP canonical asset helpers', () => {
-    it('uploads canonical attachments to object storage before recording durable cloud metadata', async () => {
-        const { projectRoot, core, cleanup } = makeCore();
-        try {
-            core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-            const task = core.createTask({ title: 'Object-backed attachment' }, { workspaceId: 'workspace-1' });
-            const relativePath = '.taskforce/workspaces/workspace-1/assets/documents/asset-test-note.md';
-            const absolutePath = path.join(projectRoot, relativePath);
-            fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
-            fs.writeFileSync(absolutePath, '# Stored in object storage\n', 'utf8');
-            const putObject = vi.fn(async () => { });
-            const helpers = createCanonicalAssetHelpers({
-                activeWorkspaceId: 'workspace-1',
-                projectRoot,
-                basePath: core.getPaths().basePath,
-                workspaceAssetStore: core.getWorkspaceAssetStore(),
-                objectStorageClient: {
-                    getObject: vi.fn(async () => null),
-                    putObject,
-                },
-                sanitizeFilenameForPath: (value, fallback = 'file.txt') => String(value || fallback).trim() || fallback,
-                sanitizeDisplayName: (value, fallback) => String(value || fallback).trim() || fallback,
-                toPosixPath: (value) => value.replace(/\\/g, '/'),
-                inferMimeTypeFromPath: (value) => value.endsWith('.md') ? 'text/markdown' : 'application/octet-stream',
-                inferAssetKind: (value, mimeType) => (value.endsWith('.md') || mimeType === 'text/markdown' ? 'document' : 'file'),
-                buildCanonicalWorkspaceAssetRelativePath: () => ({
-                    assetId: 'asset-test-note',
-                    relativePath: 'workspaces/workspace-1/assets/documents/asset-test-note.md'
-                })
-            });
-            const asset = await helpers.ensureCanonicalTaskAttachment(relativePath, task.id, 'note.md', '2026-04-27T01:00:00.000Z', 'attachment', { originalFilename: 'note.md', logicalName: 'note.md' });
-            expect(putObject).toHaveBeenCalledWith('workspaces/workspace-1/assets/documents/asset-test-note.md', Buffer.from('# Stored in object storage\n', 'utf8'), 'text/markdown');
-            expect(asset?.storageProvider).toBe('r2');
-            expect(core.getWorkspaceAssetStore().get(asset.assetId, 'workspace-1')?.storageProvider).toBe('r2');
-            expect(core.getWorkspaceAssetStore().listLinksForTask(task.id, 'workspace-1')).toEqual(expect.arrayContaining([
-                expect.objectContaining({
-                    assetId: asset?.assetId,
-                    targetType: 'task',
-                    role: 'attachment',
-                    deletedAt: null,
-                })
-            ]));
-        }
-        finally {
-            core.close();
-            cleanup();
-        }
-    });
-});

package/dist/mcp/clientIntegrations.test.d.ts

@@ -1 +0,0 @@
-export {};