opentasks 0.0.6 → 0.0.7

package/dist/graph/__tests__/provider-store.test.js

@@ -0,0 +1,791 @@
+/**
+ * Tests for Provider-Aware Graph Store
+ */
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { createProviderAwareStore, } from '../provider-store.js';
+import { createProviderRegistry } from '../../providers/registry.js';
+describe('ProviderAwareStore', () => {
+    let baseStore;
+    let providerStore;
+    let mockBeadsProvider;
+    // Mock nodes
+    const mockSpec = {
+        id: 's-abc1',
+        uuid: 'uuid-1',
+        type: 'spec',
+        title: 'Test Spec',
+        content: 'Spec content',
+        created_at: '2024-01-01T00:00:00.000Z',
+        updated_at: '2024-01-01T00:00:00.000Z',
+    };
+    const mockExternalNode = {
+        id: 'x-ext1',
+        uuid: 'uuid-ext-1',
+        type: 'external',
+        title: 'External Issue',
+        uri: 'beads://./bd-123',
+        source: 'beads',
+        materialized: true,
+        cached_at: new Date().toISOString(),
+        created_at: '2024-01-01T00:00:00.000Z',
+        updated_at: '2024-01-01T00:00:00.000Z',
+    };
+    const mockProviderNode = {
+        id: 'bd-123',
+        uri: 'beads://./bd-123',
+        type: 'issue',
+        title: 'Beads Issue',
+        content: 'Issue content',
+        status: 'open',
+        priority: 2,
+        rawData: { custom: 'data' },
+        fetchedAt: '2024-01-01T00:00:00.000Z',
+    };
+    beforeEach(() => {
+        vi.useFakeTimers();
+        // Create mock base store
+        baseStore = {
+            getNode: vi.fn(),
+            createNode: vi.fn(),
+            updateNode: vi.fn(),
+            deleteNode: vi.fn(),
+            query: {
+                nodes: vi.fn().mockResolvedValue([]),
+                edges: vi.fn(),
+                blockers: vi.fn(),
+                blocking: vi.fn(),
+                ready: vi.fn(),
+                children: vi.fn(),
+                descendants: vi.fn(),
+                ancestors: vi.fn(),
+                feedback: vi.fn(),
+            },
+            initialize: vi.fn(),
+            close: vi.fn(),
+            flush: vi.fn(),
+            createEdge: vi.fn(),
+            getEdge: vi.fn(),
+            deleteEdge: vi.fn(),
+            restoreNode: vi.fn(),
+            addTags: vi.fn(),
+            removeTags: vi.fn(),
+            setTags: vi.fn(),
+            transaction: vi.fn(),
+        };
+        // Create mock beads provider
+        mockBeadsProvider = {
+            name: 'beads',
+            schemes: ['beads', 'bd'],
+            capabilities: { read: true, write: true, search: true, watch: false, mount: true, feedback: false },
+            parseUri: vi.fn((uri) => {
+                if (uri.startsWith('beads://') || uri.startsWith('bd://')) {
+                    const id = uri.split('/').pop() || '';
+                    return { scheme: 'beads', id, isRelative: uri.includes('/.') };
+                }
+                return null;
+            }),
+            buildUri: vi.fn((id) => `beads://./${id}`),
+            isValidUri: vi.fn((uri) => uri.startsWith('beads://') || uri.startsWith('bd://')),
+            get: vi.fn().mockResolvedValue(mockProviderNode),
+            list: vi.fn(),
+            create: vi.fn(),
+            update: vi.fn(),
+            delete: vi.fn(),
+        };
+        // Create provider store
+        providerStore = createProviderAwareStore(baseStore);
+    });
+    afterEach(() => {
+        providerStore.stopBackgroundSync();
+        vi.useRealTimers();
+    });
+    describe('initialization', () => {
+        it('should have providers registry', () => {
+            expect(providerStore.providers).toBeDefined();
+            expect(providerStore.providers.list).toBeDefined();
+        });
+        it('should have materialization manager', () => {
+            expect(providerStore.materialization).toBeDefined();
+            expect(providerStore.materialization.config).toBeDefined();
+        });
+        it('should auto-register native provider', () => {
+            const nativeProvider = providerStore.providers.get('native');
+            expect(nativeProvider).toBeDefined();
+            expect(nativeProvider?.name).toBe('native');
+        });
+        it('should not auto-register native provider when disabled', () => {
+            const storeWithoutNative = createProviderAwareStore(baseStore, {
+                autoRegisterNative: false,
+            });
+            expect(storeWithoutNative.providers.get('native')).toBeUndefined();
+        });
+        it('should use provided registry', () => {
+            const customRegistry = createProviderRegistry();
+            customRegistry.register(mockBeadsProvider);
+            const storeWithCustomRegistry = createProviderAwareStore(baseStore, {
+                registry: customRegistry,
+                autoRegisterNative: false,
+            });
+            expect(storeWithCustomRegistry.providers.get('beads')).toBe(mockBeadsProvider);
+        });
+    });
+    describe('resolveNode', () => {
+        describe('local IDs', () => {
+            it('should resolve local IDs via getNode', async () => {
+                vi.mocked(baseStore.getNode).mockResolvedValue(mockSpec);
+                const result = await providerStore.resolveNode('s-abc1');
+                expect(baseStore.getNode).toHaveBeenCalledWith('s-abc1');
+                expect(result).toBe(mockSpec);
+            });
+            it('should return null for non-existent local node', async () => {
+                vi.mocked(baseStore.getNode).mockResolvedValue(null);
+                const result = await providerStore.resolveNode('s-notfound');
+                expect(result).toBeNull();
+            });
+            it('should handle all local ID prefixes', async () => {
+                vi.mocked(baseStore.getNode).mockResolvedValue(mockSpec);
+                for (const prefix of ['s-', 'i-', 'f-', 'e-', 'x-']) {
+                    await providerStore.resolveNode(`${prefix}abc1`);
+                    expect(baseStore.getNode).toHaveBeenCalledWith(`${prefix}abc1`);
+                }
+            });
+        });
+        describe('external URIs', () => {
+            beforeEach(() => {
+                providerStore.providers.register(mockBeadsProvider);
+            });
+            it('should resolve URIs via provider', async () => {
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                const result = await providerStore.resolveNode('beads://./bd-123');
+                expect(mockBeadsProvider.get).toHaveBeenCalledWith('bd-123', undefined);
+                expect(result).toBeDefined();
+            });
+            it('should return null for unknown schemes', async () => {
+                const result = await providerStore.resolveNode('unknown://./something');
+                expect(result).toBeNull();
+            });
+            it('should use cached node when not stale', async () => {
+                const freshNode = {
+                    ...mockExternalNode,
+                    cached_at: new Date().toISOString(),
+                };
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([freshNode]);
+                const result = await providerStore.resolveNode('beads://./bd-123');
+                expect(mockBeadsProvider.get).not.toHaveBeenCalled();
+                expect(result).toEqual(freshNode);
+            });
+            it('should bypass cache when refresh=true', async () => {
+                const freshNode = {
+                    ...mockExternalNode,
+                    cached_at: new Date().toISOString(),
+                };
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([freshNode]);
+                await providerStore.resolveNode('beads://./bd-123', { refresh: true });
+                expect(mockBeadsProvider.get).toHaveBeenCalled();
+            });
+            it('should materialize when explicitly requested', async () => {
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                vi.mocked(baseStore.createNode).mockResolvedValue(mockExternalNode);
+                const result = await providerStore.resolveNode('beads://./bd-123', {
+                    materialize: true,
+                });
+                expect(baseStore.createNode).toHaveBeenCalledWith(expect.objectContaining({
+                    type: 'external',
+                    uri: 'beads://./bd-123',
+                }));
+            });
+            it('should return provider node directly when not materializing', async () => {
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                const result = await providerStore.resolveNode('beads://./bd-123');
+                // With on-demand strategy (default), should not materialize without explicit flag
+                expect(baseStore.createNode).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('materializeNode', () => {
+        beforeEach(() => {
+            providerStore.providers.register(mockBeadsProvider);
+        });
+        it('should create external node from provider data', async () => {
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+            vi.mocked(baseStore.createNode).mockResolvedValue(mockExternalNode);
+            const result = await providerStore.materializeNode('beads://./bd-123');
+            expect(mockBeadsProvider.get).toHaveBeenCalledWith('bd-123');
+            expect(baseStore.createNode).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'external',
+                uri: 'beads://./bd-123',
+                source: 'beads',
+                title: 'Beads Issue',
+            }));
+        });
+        it('should throw for unknown URI scheme', async () => {
+            await expect(providerStore.materializeNode('unknown://./something')).rejects.toThrow('No provider found');
+        });
+        it('should throw if node not found in provider', async () => {
+            vi.mocked(mockBeadsProvider.get).mockResolvedValue(null);
+            await expect(providerStore.materializeNode('beads://./bd-notfound')).rejects.toThrow('Node not found');
+        });
+        it('should update existing node if already materialized', async () => {
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([mockExternalNode]);
+            vi.mocked(baseStore.updateNode).mockResolvedValue(mockExternalNode);
+            await providerStore.materializeNode('beads://./bd-123');
+            expect(baseStore.updateNode).toHaveBeenCalled();
+            expect(baseStore.createNode).not.toHaveBeenCalled();
+        });
+    });
+    describe('refreshNode', () => {
+        beforeEach(() => {
+            providerStore.providers.register(mockBeadsProvider);
+        });
+        it('should refresh an external node', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockExternalNode);
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([mockExternalNode]);
+            vi.mocked(baseStore.updateNode).mockResolvedValue(mockExternalNode);
+            const result = await providerStore.refreshNode('x-ext1');
+            expect(mockBeadsProvider.get).toHaveBeenCalledWith('beads://./bd-123', undefined);
+            expect(baseStore.updateNode).toHaveBeenCalled();
+        });
+        it('should throw for non-external node', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockSpec);
+            await expect(providerStore.refreshNode('s-abc1')).rejects.toThrow('not external');
+        });
+        it('should throw for non-existent node', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(null);
+            await expect(providerStore.refreshNode('x-notfound')).rejects.toThrow('Node not found');
+        });
+    });
+    describe('background sync', () => {
+        it('should start and stop background sync', () => {
+            providerStore = createProviderAwareStore(baseStore, {
+                materialization: {
+                    backgroundSyncInterval: 1000,
+                },
+            });
+            expect(providerStore.isBackgroundSyncRunning()).toBe(false);
+            providerStore.startBackgroundSync();
+            expect(providerStore.isBackgroundSyncRunning()).toBe(true);
+            providerStore.stopBackgroundSync();
+            expect(providerStore.isBackgroundSyncRunning()).toBe(false);
+        });
+        it('should not start if interval is 0', () => {
+            providerStore = createProviderAwareStore(baseStore, {
+                materialization: {
+                    backgroundSyncInterval: 0,
+                },
+            });
+            providerStore.startBackgroundSync();
+            expect(providerStore.isBackgroundSyncRunning()).toBe(false);
+        });
+    });
+    describe('provider registration', () => {
+        it('should allow registering additional providers', () => {
+            providerStore.providers.register(mockBeadsProvider);
+            expect(providerStore.providers.get('beads')).toBe(mockBeadsProvider);
+            expect(providerStore.providers.canResolve('beads://./bd-123')).toBe(true);
+        });
+        it('should allow unregistering providers', () => {
+            providerStore.providers.register(mockBeadsProvider);
+            providerStore.providers.unregister('beads');
+            expect(providerStore.providers.get('beads')).toBeUndefined();
+        });
+    });
+    describe('base store methods', () => {
+        it('should pass through getNode to base store', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockSpec);
+            const result = await providerStore.getNode('s-abc1');
+            expect(baseStore.getNode).toHaveBeenCalledWith('s-abc1');
+            expect(result).toBe(mockSpec);
+        });
+        it('should pass through createNode to base store', async () => {
+            vi.mocked(baseStore.createNode).mockResolvedValue(mockSpec);
+            const result = await providerStore.createNode({
+                type: 'spec',
+                title: 'New Spec',
+            });
+            expect(baseStore.createNode).toHaveBeenCalled();
+            expect(result).toBe(mockSpec);
+        });
+        it('should pass through query to base store', async () => {
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([mockSpec]);
+            const result = await providerStore.query.nodes({ type: 'spec' });
+            expect(baseStore.query.nodes).toHaveBeenCalledWith({ type: 'spec' });
+            expect(result).toEqual([mockSpec]);
+        });
+    });
+    describe('materialization strategies', () => {
+        beforeEach(() => {
+            providerStore.providers.register(mockBeadsProvider);
+        });
+        it('should materialize with lazy strategy on resolve', async () => {
+            const lazyStore = createProviderAwareStore(baseStore, {
+                materialization: { default: 'lazy' },
+            });
+            lazyStore.providers.register(mockBeadsProvider);
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+            vi.mocked(baseStore.createNode).mockResolvedValue(mockExternalNode);
+            await lazyStore.resolveNode('beads://./bd-123');
+            expect(baseStore.createNode).toHaveBeenCalled();
+        });
+        it('should materialize with eager strategy always', async () => {
+            const eagerStore = createProviderAwareStore(baseStore, {
+                materialization: { default: 'eager' },
+            });
+            eagerStore.providers.register(mockBeadsProvider);
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+            vi.mocked(baseStore.createNode).mockResolvedValue(mockExternalNode);
+            await eagerStore.resolveNode('beads://./bd-123');
+            expect(baseStore.createNode).toHaveBeenCalled();
+        });
+        it('should not materialize with none strategy', async () => {
+            const noneStore = createProviderAwareStore(baseStore, {
+                materialization: { default: 'none' },
+            });
+            noneStore.providers.register(mockBeadsProvider);
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+            await noneStore.resolveNode('beads://./bd-123', { materialize: true });
+            // Even with explicit flag, 'none' should not materialize
+            expect(baseStore.createNode).not.toHaveBeenCalled();
+        });
+    });
+    // ===========================================================================
+    // Provider-Routed CRUD (Unified Interface)
+    // ===========================================================================
+    describe('providerCreate', () => {
+        it('should create locally when defaultProvider is native', async () => {
+            const store = createProviderAwareStore(baseStore, {
+                defaultProvider: 'native',
+            });
+            const mockNode = { ...mockSpec };
+            vi.mocked(baseStore.createNode).mockResolvedValue(mockNode);
+            const result = await store.providerCreate({
+                type: 'spec',
+                title: 'Test Spec',
+            });
+            expect(result.provider).toBe('native');
+            expect(result.uri).toBeUndefined();
+            expect(baseStore.createNode).toHaveBeenCalledWith({
+                type: 'spec',
+                title: 'Test Spec',
+            });
+        });
+        it('should route to external provider via scheme param', async () => {
+            const store = createProviderAwareStore(baseStore, {
+                defaultProvider: 'native',
+            });
+            store.providers.register(mockBeadsProvider);
+            const createdProviderNode = {
+                id: 'bd-new1',
+                uri: 'beads://./bd-new1',
+                type: 'issue',
+                title: 'New Issue',
+                fetchedAt: new Date().toISOString(),
+            };
+            vi.mocked(mockBeadsProvider.create).mockResolvedValue(createdProviderNode);
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+            vi.mocked(baseStore.createNode).mockResolvedValue({
+                ...mockExternalNode,
+                id: 'x-new1',
+                title: 'New Issue',
+                uri: 'beads://./bd-new1',
+            });
+            const result = await store.providerCreate({ type: 'issue', title: 'New Issue' }, { scheme: 'beads' });
+            expect(result.provider).toBe('beads');
+            expect(result.uri).toBe('beads://./bd-new1');
+            expect(mockBeadsProvider.create).toHaveBeenCalledWith({
+                type: 'issue',
+                title: 'New Issue',
+                content: undefined,
+                status: undefined,
+                priority: undefined,
+                metadata: undefined,
+            }, undefined);
+            // Should materialize the node locally
+            expect(baseStore.createNode).toHaveBeenCalled();
+        });
+        it('should use defaultProvider when no scheme specified', async () => {
+            const store = createProviderAwareStore(baseStore, {
+                defaultProvider: 'beads',
+            });
+            store.providers.register(mockBeadsProvider);
+            const createdProviderNode = {
+                id: 'bd-new2',
+                uri: 'beads://./bd-new2',
+                type: 'issue',
+                title: 'Default Provider Issue',
+                fetchedAt: new Date().toISOString(),
+            };
+            vi.mocked(mockBeadsProvider.create).mockResolvedValue(createdProviderNode);
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+            vi.mocked(baseStore.createNode).mockResolvedValue({
+                ...mockExternalNode,
+                id: 'x-new2',
+            });
+            const result = await store.providerCreate({
+                type: 'issue',
+                title: 'Default Provider Issue',
+            });
+            // Should route to beads since it's the defaultProvider
+            expect(result.provider).toBe('beads');
+            expect(mockBeadsProvider.create).toHaveBeenCalled();
+        });
+        it('should throw for unknown provider', async () => {
+            const store = createProviderAwareStore(baseStore);
+            await expect(store.providerCreate({ type: 'issue', title: 'Test' }, { scheme: 'nonexistent' })).rejects.toThrow('Unknown provider: nonexistent');
+        });
+        it('should throw for read-only provider', async () => {
+            const readOnlyProvider = {
+                ...mockBeadsProvider,
+                name: 'readonly',
+                schemes: ['readonly'],
+                capabilities: { read: true, write: false, search: false, watch: false, mount: false, feedback: false },
+            };
+            const store = createProviderAwareStore(baseStore);
+            store.providers.register(readOnlyProvider);
+            await expect(store.providerCreate({ type: 'issue', title: 'Test' }, { scheme: 'readonly' })).rejects.toThrow('read-only');
+        });
+        it('should throw for non-mountable provider', async () => {
+            const nonMountable = {
+                ...mockBeadsProvider,
+                name: 'nomount',
+                schemes: ['nomount'],
+                capabilities: { read: true, write: true, search: false, watch: false, mount: false, feedback: false },
+            };
+            const store = createProviderAwareStore(baseStore);
+            store.providers.register(nonMountable);
+            await expect(store.providerCreate({ type: 'issue', title: 'Test' }, { scheme: 'nomount' })).rejects.toThrow('does not support mounting');
+        });
+    });
+    describe('providerGet', () => {
+        it('should get local node directly', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockSpec);
+            const result = await providerStore.providerGet('s-abc1');
+            expect(baseStore.getNode).toHaveBeenCalledWith('s-abc1');
+            expect(result).toEqual(mockSpec);
+        });
+        it('should refresh stale external node', async () => {
+            const staleNode = {
+                ...mockExternalNode,
+                cached_at: '2020-01-01T00:00:00.000Z', // very old
+            };
+            vi.mocked(baseStore.getNode).mockResolvedValue(staleNode);
+            providerStore.providers.register(mockBeadsProvider);
+            // Mock the refresh path: query for existing, then update
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([staleNode]);
+            vi.mocked(baseStore.updateNode).mockResolvedValue({
+                ...staleNode,
+                title: 'Beads Issue',
+                cached_at: new Date().toISOString(),
+            });
+            const result = await providerStore.providerGet('x-ext1');
+            expect(mockBeadsProvider.get).toHaveBeenCalled();
+        });
+        it('should resolve provider URI and materialize', async () => {
+            providerStore.providers.register(mockBeadsProvider);
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+            vi.mocked(baseStore.createNode).mockResolvedValue(mockExternalNode);
+            const result = await providerStore.providerGet('beads://./bd-123');
+            expect(mockBeadsProvider.get).toHaveBeenCalled();
+        });
+        it('should return null for nonexistent local node', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(null);
+            const result = await providerStore.providerGet('s-nonexist');
+            expect(result).toBeNull();
+        });
+    });
+    describe('providerUpdate', () => {
+        it('should update local node directly', async () => {
+            const updatedNode = { ...mockSpec, title: 'Updated' };
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockSpec);
+            vi.mocked(baseStore.updateNode).mockResolvedValue(updatedNode);
+            const result = await providerStore.providerUpdate('s-abc1', { title: 'Updated' });
+            expect(baseStore.updateNode).toHaveBeenCalledWith('s-abc1', { title: 'Updated' });
+            expect(result.title).toBe('Updated');
+        });
+        it('should route update to external provider for materialized node', async () => {
+            providerStore.providers.register(mockBeadsProvider);
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockExternalNode);
+            const updatedProviderNode = {
+                ...mockProviderNode,
+                title: 'Updated in Beads',
+            };
+            vi.mocked(mockBeadsProvider.update).mockResolvedValue(updatedProviderNode);
+            // Mock materialization (find existing, then update)
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([mockExternalNode]);
+            vi.mocked(baseStore.updateNode).mockResolvedValue({
+                ...mockExternalNode,
+                title: 'Updated in Beads',
+            });
+            const result = await providerStore.providerUpdate('x-ext1', { title: 'Updated in Beads' });
+            expect(mockBeadsProvider.update).toHaveBeenCalledWith('bd-123', {
+                title: 'Updated in Beads',
+                content: undefined,
+                status: undefined,
+                priority: undefined,
+                metadata: undefined,
+            }, undefined);
+        });
+        it('should route update via provider URI', async () => {
+            providerStore.providers.register(mockBeadsProvider);
+            // No existing materialized copy
+            vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+            // Mock fetching the node for materialization
+            vi.mocked(baseStore.createNode).mockResolvedValue(mockExternalNode);
+            const updatedProviderNode = {
+                ...mockProviderNode,
+                title: 'Updated via URI',
+            };
+            vi.mocked(mockBeadsProvider.update).mockResolvedValue(updatedProviderNode);
+            // After materialization, the update path will re-materialize
+            vi.mocked(baseStore.updateNode).mockResolvedValue({
+                ...mockExternalNode,
+                title: 'Updated via URI',
+            });
+            const result = await providerStore.providerUpdate('beads://./bd-123', { title: 'Updated via URI' });
+            expect(mockBeadsProvider.update).toHaveBeenCalled();
+        });
+        it('should throw for nonexistent node', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(null);
+            await expect(providerStore.providerUpdate('s-nonexist', { title: 'Test' })).rejects.toThrow('not found');
+        });
+        it('should throw when external node provider is not registered', async () => {
+            // External node exists but its provider (beads) is NOT registered
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockExternalNode);
+            await expect(providerStore.providerUpdate('x-ext1', { title: 'Update' })).rejects.toThrow('Provider not registered');
+        });
+    });
+    describe('providerDelete', () => {
+        it('should delete local node directly', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockSpec);
+            vi.mocked(baseStore.deleteNode).mockResolvedValue(undefined);
+            await providerStore.providerDelete('s-abc1');
+            expect(baseStore.deleteNode).toHaveBeenCalledWith('s-abc1', undefined);
+        });
+        it('should route delete to external provider and remove local copy', async () => {
+            providerStore.providers.register(mockBeadsProvider);
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockExternalNode);
+            vi.mocked(mockBeadsProvider.delete).mockResolvedValue(undefined);
+            vi.mocked(baseStore.deleteNode).mockResolvedValue(undefined);
+            await providerStore.providerDelete('x-ext1');
+            // Should delete in provider
+            expect(mockBeadsProvider.delete).toHaveBeenCalledWith('bd-123', undefined);
+            // Should hard-delete local materialized copy
+            expect(baseStore.deleteNode).toHaveBeenCalledWith('x-ext1', { hard: true });
+        });
+        it('should throw for nonexistent node', async () => {
+            vi.mocked(baseStore.getNode).mockResolvedValue(null);
+            await expect(providerStore.providerDelete('s-nonexist')).rejects.toThrow('not found');
+        });
+        it('should throw when external node provider is not registered', async () => {
+            // External node exists but its provider (beads) is NOT registered
+            vi.mocked(baseStore.getNode).mockResolvedValue(mockExternalNode);
+            await expect(providerStore.providerDelete('x-ext1')).rejects.toThrow('Provider not registered');
+        });
+    });
+    describe('defaultProvider', () => {
+        it('should default to native', () => {
+            const store = createProviderAwareStore(baseStore);
+            expect(store.defaultProvider).toBe('native');
+        });
+        it('should respect config', () => {
+            const store = createProviderAwareStore(baseStore, {
+                defaultProvider: 'sudocode',
+            });
+            expect(store.defaultProvider).toBe('sudocode');
+        });
+    });
+    // =========================================================================
+    // Task Lifecycle (TaskManageable)
+    // =========================================================================
+    describe('task lifecycle', () => {
+        let mockTaskProvider;
+        const mockTaskProviderNode = {
+            id: 'task-1',
+            uri: 'taskprov://task-1',
+            type: 'issue',
+            title: 'Task One',
+            status: 'in_progress',
+            fetchedAt: new Date().toISOString(),
+        };
+        const mockTaskExternalNode = {
+            id: 'x-task1',
+            uuid: 'uuid-task-1',
+            type: 'external',
+            title: 'Task One',
+            uri: 'taskprov://task-1',
+            source: 'taskprov',
+            materialized: true,
+            cached_at: new Date().toISOString(),
+            created_at: '2024-01-01T00:00:00.000Z',
+            updated_at: '2024-01-01T00:00:00.000Z',
+        };
+        beforeEach(() => {
+            mockTaskProvider = {
+                name: 'taskprov',
+                schemes: ['taskprov'],
+                capabilities: { read: true, write: true, search: false, watch: false, mount: true, feedback: false },
+                parseUri: vi.fn((uri) => {
+                    if (uri.startsWith('taskprov://')) {
+                        const id = uri.slice('taskprov://'.length);
+                        return { scheme: 'taskprov', id, isRelative: false };
+                    }
+                    return null;
+                }),
+                buildUri: vi.fn((id) => `taskprov://${id}`),
+                isValidUri: vi.fn((uri) => uri.startsWith('taskprov://')),
+                get: vi.fn().mockResolvedValue(mockTaskProviderNode),
+                list: vi.fn().mockResolvedValue([]),
+                create: vi.fn(),
+                update: vi.fn(),
+                delete: vi.fn(),
+                taskCapabilities: {
+                    actions: ['start', 'complete', 'block', 'reopen'],
+                    supportsAssignment: true,
+                    supportsReadyQuery: true,
+                    statusModel: ['open', 'in_progress', 'blocked', 'done'],
+                },
+                transitionTask: vi.fn().mockResolvedValue(mockTaskProviderNode),
+                readyTasks: vi.fn().mockResolvedValue([mockTaskProviderNode]),
+                assignTask: vi.fn().mockResolvedValue(mockTaskProviderNode),
+                validActions: vi.fn().mockResolvedValue(['start', 'close']),
+            };
+        });
+        describe('taskTransition', () => {
+            it('should transition a task via provider URI', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                // Mock materialization: no existing node, so create one
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                vi.mocked(baseStore.createNode).mockResolvedValue(mockTaskExternalNode);
+                const result = await providerStore.taskTransition('taskprov://task-1', 'start');
+                expect(mockTaskProvider.transitionTask).toHaveBeenCalledWith('task-1', 'start', undefined);
+                expect(result.action).toBe('start');
+                expect(result.provider).toBe('taskprov');
+                expect(result.node).toBeDefined();
+            });
+            it('should transition a task via local external node ID', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                vi.mocked(baseStore.getNode).mockResolvedValue(mockTaskExternalNode);
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([mockTaskExternalNode]);
+                vi.mocked(baseStore.updateNode).mockResolvedValue(mockTaskExternalNode);
+                const result = await providerStore.taskTransition('x-task1', 'complete');
+                expect(mockTaskProvider.transitionTask).toHaveBeenCalledWith('task-1', 'complete', undefined);
+                expect(result.action).toBe('complete');
+            });
+            it('should throw for provider that does not support tasks', async () => {
+                providerStore.providers.register(mockBeadsProvider);
+                await expect(providerStore.taskTransition('beads://./bd-123', 'start')).rejects.toThrow('does not support task operations');
+            });
+            it('should throw for nonexistent node', async () => {
+                vi.mocked(baseStore.getNode).mockResolvedValue(null);
+                await expect(providerStore.taskTransition('s-nonexist', 'start')).rejects.toThrow('not found');
+            });
+            it('should forward context to provider', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                vi.mocked(baseStore.createNode).mockResolvedValue(mockTaskExternalNode);
+                const ctx = { cwd: '/other/dir', timeout: 5000 };
+                await providerStore.taskTransition('taskprov://task-1', 'start', { context: ctx });
+                expect(mockTaskProvider.transitionTask).toHaveBeenCalledWith('task-1', 'start', ctx);
+            });
+        });
+        describe('taskReady', () => {
+            it('should aggregate ready tasks across task-capable providers', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                // Mock materialization for each ready task
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                vi.mocked(baseStore.createNode).mockResolvedValue(mockTaskExternalNode);
+                const ready = await providerStore.taskReady();
+                expect(mockTaskProvider.readyTasks).toHaveBeenCalled();
+                expect(ready.length).toBeGreaterThanOrEqual(1);
+            });
+            it('should skip non-task-capable providers', async () => {
+                providerStore.providers.register(mockBeadsProvider);
+                providerStore.providers.register(mockTaskProvider);
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                vi.mocked(baseStore.createNode).mockResolvedValue(mockTaskExternalNode);
+                await providerStore.taskReady();
+                // Only taskprov should be queried
+                expect(mockTaskProvider.readyTasks).toHaveBeenCalled();
+            });
+            it('should filter by provider name', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                await providerStore.taskReady({ providers: ['other-provider'] });
+                // taskprov should NOT be queried because it wasn't in the filter
+                expect(mockTaskProvider.readyTasks).not.toHaveBeenCalled();
+            });
+            it('should return existing materialized nodes when available', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                // Mock: existing materialized node found
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([mockTaskExternalNode]);
+                const ready = await providerStore.taskReady();
+                expect(ready[0]).toEqual(mockTaskExternalNode);
+            });
+            it('should forward options to provider', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                vi.mocked(baseStore.createNode).mockResolvedValue(mockTaskExternalNode);
+                await providerStore.taskReady({ limit: 5, tags: ['urgent'], assignee: 'alice' });
+                expect(mockTaskProvider.readyTasks).toHaveBeenCalledWith({ limit: 5, tags: ['urgent'], priority: undefined, assignee: 'alice' }, undefined);
+            });
+        });
+        describe('taskAssign', () => {
+            it('should assign a task via provider', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                vi.mocked(baseStore.query.nodes).mockResolvedValue([]);
+                vi.mocked(baseStore.createNode).mockResolvedValue(mockTaskExternalNode);
+                const result = await providerStore.taskAssign('taskprov://task-1', 'alice');
+                expect(mockTaskProvider.assignTask).toHaveBeenCalledWith('task-1', 'alice', undefined);
+                expect(result).toBeDefined();
+            });
+            it('should throw for provider that does not support assignment', async () => {
+                const noAssignProvider = {
+                    ...mockTaskProvider,
+                    name: 'noassign',
+                    schemes: ['noassign'],
+                    parseUri: vi.fn((uri) => {
+                        if (uri.startsWith('noassign://')) {
+                            return { scheme: 'noassign', id: uri.slice('noassign://'.length), isRelative: false };
+                        }
+                        return null;
+                    }),
+                    buildUri: vi.fn((id) => `noassign://${id}`),
+                    isValidUri: vi.fn((uri) => uri.startsWith('noassign://')),
+                    taskCapabilities: {
+                        ...mockTaskProvider.taskCapabilities,
+                        supportsAssignment: false,
+                    },
+                    assignTask: undefined,
+                };
+                providerStore.providers.register(noAssignProvider);
+                await expect(providerStore.taskAssign('noassign://task-1', 'alice')).rejects.toThrow('does not support task assignment');
+            });
+        });
+        describe('taskValidActions', () => {
+            it('should return valid actions from provider', async () => {
+                providerStore.providers.register(mockTaskProvider);
+                const actions = await providerStore.taskValidActions('taskprov://task-1');
+                expect(mockTaskProvider.validActions).toHaveBeenCalledWith('task-1');
+                expect(actions).toEqual(['start', 'close']);
+            });
+            it('should fall back to taskCapabilities.actions when validActions not implemented', async () => {
+                const noValidActionsProvider = {
+                    ...mockTaskProvider,
+                    name: 'novalid',
+                    schemes: ['novalid'],
+                    parseUri: vi.fn((uri) => {
+                        if (uri.startsWith('novalid://')) {
+                            return { scheme: 'novalid', id: uri.slice('novalid://'.length), isRelative: false };
+                        }
+                        return null;
+                    }),
+                    buildUri: vi.fn((id) => `novalid://${id}`),
+                    isValidUri: vi.fn((uri) => uri.startsWith('novalid://')),
+                    validActions: undefined,
+                };
+                providerStore.providers.register(noValidActionsProvider);
+                const actions = await providerStore.taskValidActions('novalid://task-1');
+                expect(actions).toEqual(['start', 'complete', 'block', 'reopen']);
+            });
+        });
+    });
+});
+//# sourceMappingURL=provider-store.test.js.map