@gitgov/core 1.0.0 → 1.0.2

package/dist/src/adapters/backlog_adapter/backlog_adapter.test.js

@@ -1,1282 +0,0 @@
-import { BacklogAdapter } from './index';
-// Mock the factories before importing
-jest.mock('../../factories/task_factory', () => ({
-    createTaskRecord: jest.fn()
-}));
-jest.mock('../../factories/cycle_factory', () => ({
-    createCycleRecord: jest.fn()
-}));
-// Helper to create properly typed mock records with valid IDs
-function createMockTaskRecord(payload) {
-    const baseId = payload.id || '1757687335-task-mock-task';
-    return {
-        header: {
-            version: '1.0',
-            type: 'task',
-            payloadChecksum: 'mock-checksum',
-            signatures: [{ keyId: 'mock-author', role: 'author', signature: 'mock-sig', timestamp: 123, timestamp_iso: '2025-01-01T00:00:00Z' }]
-        },
-        payload: {
-            id: baseId,
-            title: 'Mock Task',
-            status: 'draft',
-            priority: 'medium',
-            description: 'Mock description',
-            tags: [],
-            cycleIds: [],
-            ...payload
-        }
-    };
-}
-function createMockCycleRecord(payload) {
-    const baseId = payload.id || '1757687335-cycle-mock-cycle';
-    return {
-        header: {
-            version: '1.0',
-            type: 'cycle',
-            payloadChecksum: 'mock-checksum',
-            signatures: [{ keyId: 'mock-author', role: 'author', signature: 'mock-sig', timestamp: 123, timestamp_iso: '2025-01-01T00:00:00Z' }]
-        },
-        payload: {
-            id: baseId,
-            title: 'Mock Cycle',
-            status: 'planning',
-            taskIds: [],
-            childCycleIds: [],
-            ...payload
-        }
-    };
-}
-function createMockFeedbackRecord(payload) {
-    const baseId = payload.id || '1757687335-feedback-mock';
-    return {
-        header: {
-            version: '1.0',
-            type: 'feedback',
-            payloadChecksum: 'mock-checksum',
-            signatures: [{ keyId: 'mock-author', role: 'author', signature: 'mock-sig', timestamp: 123, timestamp_iso: '2025-01-01T00:00:00Z' }]
-        },
-        payload: {
-            id: baseId,
-            entityType: 'task',
-            entityId: '1757687335-task-test',
-            type: 'assignment',
-            status: 'open',
-            content: 'Mock feedback content',
-            priority: 'medium',
-            tags: [],
-            ...payload
-        }
-    };
-}
-// Complete unit tests for BacklogAdapter
-describe('BacklogAdapter - Complete Unit Tests', () => {
-    let backlogAdapter;
-    let mockDependencies;
-    beforeEach(() => {
-        // Complete setup for unit tests
-        mockDependencies = {
-            taskStore: {
-                list: jest.fn().mockResolvedValue([]),
-                read: jest.fn(),
-                write: jest.fn()
-            },
-            cycleStore: {
-                list: jest.fn().mockResolvedValue([]),
-                read: jest.fn(),
-                write: jest.fn()
-            },
-            feedbackStore: {
-                read: jest.fn(),
-                list: jest.fn().mockResolvedValue([]),
-                write: jest.fn()
-            },
-            executionStore: {
-                read: jest.fn(),
-                list: jest.fn().mockResolvedValue([]),
-                write: jest.fn()
-            },
-            changelogStore: {
-                read: jest.fn(),
-                list: jest.fn().mockResolvedValue([]),
-                write: jest.fn()
-            },
-            feedbackAdapter: {
-                create: jest.fn()
-            },
-            executionAdapter: {
-                isFirstExecution: jest.fn()
-            },
-            changelogAdapter: {
-                create: jest.fn()
-            },
-            metricsAdapter: {
-                getSystemStatus: jest.fn().mockResolvedValue({
-                    tasks: { total: 0, byStatus: {}, byPriority: {} },
-                    cycles: { total: 0, active: 0, completed: 0 },
-                    health: { overallScore: 100, blockedTasks: 0, staleTasks: 0 }
-                }),
-                getTaskHealth: jest.fn().mockResolvedValue({
-                    taskId: 'task-123',
-                    healthScore: 85,
-                    timeInCurrentStage: 2,
-                    stalenessIndex: 1,
-                    blockingFeedbacks: 0,
-                    lastActivity: Date.now(),
-                    recommendations: []
-                })
-            },
-            workflowMethodologyAdapter: {
-                getTransitionRule: jest.fn(),
-                validateSignature: jest.fn(),
-                getAvailableTransitions: jest.fn()
-            },
-            identity: {
-                getActor: jest.fn(),
-                signRecord: jest.fn().mockImplementation(async (record) => record)
-            },
-            eventBus: {
-                publish: jest.fn(),
-                subscribe: jest.fn(),
-                unsubscribe: jest.fn(),
-                getSubscriptions: jest.fn(),
-                clearSubscriptions: jest.fn()
-            }
-        };
-        backlogAdapter = new BacklogAdapter(mockDependencies);
-    });
-    it('[EARS-32] should do nothing for non-blocking feedback', async () => {
-        const event = {
-            type: 'feedback.created',
-            timestamp: Date.now(),
-            source: 'feedback_adapter',
-            payload: {
-                feedbackId: 'feedback-123',
-                entityType: 'task',
-                entityId: 'task-123',
-                type: 'suggestion',
-                status: 'open',
-                content: 'Test feedback content',
-                triggeredBy: 'human:test-user'
-            }
-        };
-        // Should not throw error
-        await expect(backlogAdapter.handleFeedbackCreated(event)).resolves.not.toThrow();
-    });
-    it('[EARS-38] should handle daily tick events', async () => {
-        const event = {
-            type: 'system.daily_tick',
-            timestamp: Date.now(),
-            source: 'system',
-            payload: {
-                date: '2025-01-15'
-            }
-        };
-        // Should not throw error
-        await expect(backlogAdapter.handleDailyTick(event)).resolves.not.toThrow();
-    });
-    describe('Cycle Operations', () => {
-        it('[EARS-28] should create, sign, and persist a valid cycle', async () => {
-            const mockCycle = createMockCycleRecord({
-                id: '1757687335-cycle-test-cycle',
-                title: 'Test Cycle',
-                status: 'planning'
-            });
-            // Mock the factory functions
-            const { createCycleRecord } = require('../../factories/cycle_factory');
-            createCycleRecord.mockResolvedValue(mockCycle.payload);
-            mockDependencies.identity.signRecord.mockResolvedValue(mockCycle);
-            mockDependencies.cycleStore.write.mockResolvedValue(undefined);
-            const result = await backlogAdapter.createCycle({
-                title: 'Test Cycle',
-                status: 'planning'
-            }, 'human:author');
-            expect(mockDependencies.cycleStore.write).toHaveBeenCalled();
-            expect(mockDependencies.eventBus.publish).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'cycle.created',
-                payload: expect.objectContaining({
-                    actorId: 'human:author'
-                })
-            }));
-            expect(result).toEqual(mockCycle.payload);
-        });
-        it('[EARS-29] should read a cycle by its ID', async () => {
-            const mockCycle = createMockCycleRecord({
-                id: '1757687335-cycle-test-cycle',
-                title: 'Test Cycle'
-            });
-            mockDependencies.cycleStore.read.mockResolvedValue(mockCycle);
-            const result = await backlogAdapter.getCycle('1757687335-cycle-test-cycle');
-            expect(mockDependencies.cycleStore.read).toHaveBeenCalledWith('1757687335-cycle-test-cycle');
-            expect(result).toEqual(mockCycle.payload);
-        });
-        it('[EARS-29] should return null for non-existent cycle', async () => {
-            mockDependencies.cycleStore.read.mockResolvedValue(null);
-            const result = await backlogAdapter.getCycle('non-existent');
-            expect(result).toBeNull();
-        });
-        it('[EARS-30] should list all cycles', async () => {
-            const mockCycles = [
-                createMockCycleRecord({ id: '1757687335-cycle-test-1', title: 'Cycle 1' }),
-                createMockCycleRecord({ id: '1757687336-cycle-test-2', title: 'Cycle 2' })
-            ];
-            mockDependencies.cycleStore.list.mockResolvedValue([
-                '1757687335-cycle-test-1',
-                '1757687336-cycle-test-2'
-            ]);
-            mockDependencies.cycleStore.read
-                .mockResolvedValueOnce(mockCycles[0])
-                .mockResolvedValueOnce(mockCycles[1]);
-            const result = await backlogAdapter.getAllCycles();
-            expect(result).toHaveLength(2);
-            expect(result[0]).toEqual(mockCycles[0]?.payload);
-            expect(result[1]).toEqual(mockCycles[1]?.payload);
-        });
-        it('[EARS-31] should update a cycle and emit event on status change', async () => {
-            const originalCycle = createMockCycleRecord({
-                id: '1757687335-cycle-test-cycle',
-                status: 'planning'
-            });
-            const updatedCycle = createMockCycleRecord({
-                id: '1757687335-cycle-test-cycle',
-                status: 'active'
-            });
-            mockDependencies.cycleStore.read.mockResolvedValue(originalCycle);
-            mockDependencies.cycleStore.write.mockResolvedValue(undefined);
-            // Mock the factory function
-            const { createCycleRecord } = require('../../factories/cycle_factory');
-            createCycleRecord.mockResolvedValue(updatedCycle.payload);
-            const result = await backlogAdapter.updateCycle('1757687335-cycle-test-cycle', { status: 'active' });
-            expect(mockDependencies.cycleStore.write).toHaveBeenCalled();
-            expect(mockDependencies.eventBus.publish).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'cycle.status.changed',
-                payload: expect.objectContaining({
-                    cycleId: '1757687335-cycle-test-cycle',
-                    oldStatus: 'planning',
-                    newStatus: 'active'
-                })
-            }));
-            expect(result).toEqual(updatedCycle.payload);
-        });
-        it('[EARS-32] should create bidirectional link between task and cycle', async () => {
-            const taskId = '1757687335-task-test-task';
-            const cycleId = '1757687335-cycle-test-cycle';
-            const mockTask = createMockTaskRecord({
-                id: taskId,
-                cycleIds: []
-            });
-            const mockCycle = createMockCycleRecord({
-                id: cycleId,
-                taskIds: []
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(mockTask);
-            mockDependencies.cycleStore.read.mockResolvedValue(mockCycle);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.cycleStore.write.mockResolvedValue(undefined);
-            // Mock getCurrentActor for the new implementation
-            mockDependencies.identity.getCurrentActor = jest.fn().mockResolvedValue({
-                id: 'human:test-user',
-                displayName: 'Test User'
-            });
-            await backlogAdapter.addTaskToCycle(cycleId, taskId);
-            expect(mockDependencies.cycleStore.write).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    taskIds: expect.arrayContaining([taskId])
-                })
-            }));
-            expect(mockDependencies.taskStore.write).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    cycleIds: expect.arrayContaining([cycleId])
-                })
-            }));
-        });
-        it('[EARS-31] should throw error when updating cycle in final state', async () => {
-            const archivedCycle = createMockCycleRecord({
-                id: '1757687335-cycle-archived',
-                status: 'archived'
-            });
-            mockDependencies.cycleStore.read.mockResolvedValue(archivedCycle);
-            await expect(backlogAdapter.updateCycle('1757687335-cycle-archived', { title: 'New Title' }))
-                .rejects.toThrow('ProtocolViolationError: Cannot update cycle in final state: archived');
-        });
-    });
-    describe('Enhanced Task Operations', () => {
-        it('[EARS-25] should correctly update task fields', async () => {
-            const originalTask = createMockTaskRecord({
-                id: '1757687335-task-test-task',
-                title: 'Original Title',
-                status: 'draft'
-            });
-            const updatedTask = createMockTaskRecord({
-                id: '1757687335-task-test-task',
-                title: 'Updated Title',
-                status: 'draft'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(originalTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            // Mock the factory function
-            const { createTaskRecord } = require('../../factories/task_factory');
-            createTaskRecord.mockResolvedValue(updatedTask.payload);
-            const result = await backlogAdapter.updateTask('1757687335-task-test-task', { title: 'Updated Title' });
-            expect(mockDependencies.taskStore.write).toHaveBeenCalled();
-            expect(result.title).toBe('Updated Title');
-        });
-        it('[EARS-26] should throw error when updating task in final state', async () => {
-            const archivedTask = createMockTaskRecord({
-                id: '1757687335-task-archived',
-                status: 'archived'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(archivedTask);
-            await expect(backlogAdapter.updateTask('1757687335-task-archived', { title: 'New Title' }))
-                .rejects.toThrow('ProtocolViolationError: Cannot update task in final state: archived');
-        });
-        it('[EARS-27] should activate task from ready to active with permission validation', async () => {
-            const taskId = '1757687335-task-ready-task';
-            const readyTask = createMockTaskRecord({
-                id: taskId,
-                status: 'ready'
-            });
-            const activeTask = createMockTaskRecord({
-                id: taskId,
-                status: 'active'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(readyTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:developer',
-                type: 'human',
-                displayName: 'Developer',
-                publicKey: 'mock-key',
-                roles: ['executor'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'active',
-                conditions: {}
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue({
-                ...readyTask,
-                payload: activeTask.payload
-            });
-            const result = await backlogAdapter.activateTask(taskId, 'human:developer');
-            expect(mockDependencies.workflowMethodologyAdapter.getTransitionRule).toHaveBeenCalledWith('ready', 'active', expect.objectContaining({
-                task: readyTask.payload,
-                transitionTo: 'active'
-            }));
-            expect(mockDependencies.identity.signRecord).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({ status: 'active' })
-            }), 'human:developer', 'executor');
-            expect(mockDependencies.taskStore.write).toHaveBeenCalled();
-            expect(mockDependencies.eventBus.publish).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'task.status.changed',
-                payload: expect.objectContaining({
-                    taskId,
-                    oldStatus: 'ready',
-                    newStatus: 'active',
-                    actorId: 'human:developer'
-                })
-            }));
-            expect(result.status).toBe('active');
-        });
-        it('[EARS-28] should throw error when task not found for activation', async () => {
-            mockDependencies.taskStore.read.mockResolvedValue(null);
-            await expect(backlogAdapter.activateTask('nonexistent-task', 'human:developer'))
-                .rejects.toThrow('RecordNotFoundError: Task not found: nonexistent-task');
-        });
-        it('[EARS-29] should throw error when task is not in ready state for activation', async () => {
-            const draftTask = createMockTaskRecord({
-                id: '1757687335-task-draft',
-                status: 'draft'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(draftTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:developer',
-                type: 'human',
-                displayName: 'Developer',
-                publicKey: 'mock-key',
-                roles: ['executor'],
-                status: 'active'
-            });
-            await expect(backlogAdapter.activateTask('1757687335-task-draft', 'human:developer'))
-                .rejects.toThrow('ProtocolViolationError: Task is in \'draft\' state. Cannot activate from this state.');
-        });
-        it('[EARS-30] should throw error when workflow methodology rejects activation', async () => {
-            const readyTask = createMockTaskRecord({
-                id: '1757687335-task-ready',
-                status: 'ready'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(readyTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:developer',
-                type: 'human',
-                displayName: 'Developer',
-                publicKey: 'mock-key',
-                roles: ['executor'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue(null);
-            await expect(backlogAdapter.activateTask('1757687335-task-ready', 'human:developer'))
-                .rejects.toThrow('ProtocolViolationError: Workflow methodology rejected ready→active transition');
-        });
-        it('[EARS-38A] should resume task from paused to active with blocking validation', async () => {
-            const taskId = '1757687335-task-paused';
-            const pausedTask = createMockTaskRecord({
-                id: taskId,
-                status: 'paused'
-            });
-            const activeTask = createMockTaskRecord({
-                id: taskId,
-                status: 'active'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(pausedTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:ops-lead',
-                type: 'human',
-                displayName: 'Ops Lead',
-                publicKey: 'mock-key',
-                roles: ['resumer'],
-                status: 'active'
-            });
-            mockDependencies.metricsAdapter.getTaskHealth.mockResolvedValue({
-                taskId,
-                healthScore: 80,
-                timeInCurrentStage: 3,
-                stalenessIndex: 1,
-                blockingFeedbacks: 0,
-                lastActivity: Date.now(),
-                recommendations: []
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'active',
-                conditions: {}
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue({
-                ...pausedTask,
-                payload: activeTask.payload
-            });
-            const result = await backlogAdapter.resumeTask(taskId, 'human:ops-lead');
-            expect(mockDependencies.metricsAdapter.getTaskHealth).toHaveBeenCalledWith(taskId);
-            expect(mockDependencies.workflowMethodologyAdapter.getTransitionRule).toHaveBeenCalledWith('paused', 'active', expect.objectContaining({
-                task: pausedTask.payload,
-                transitionTo: 'active'
-            }));
-            expect(mockDependencies.identity.signRecord).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({ status: 'active' })
-            }), 'human:ops-lead', 'resumer');
-            expect(mockDependencies.taskStore.write).toHaveBeenCalled();
-            expect(mockDependencies.eventBus.publish).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'task.status.changed',
-                payload: expect.objectContaining({
-                    taskId,
-                    oldStatus: 'paused',
-                    newStatus: 'active',
-                    actorId: 'human:ops-lead'
-                })
-            }));
-            expect(result.status).toBe('active');
-        });
-        it('[EARS-39A] should throw error when task not found for resume', async () => {
-            mockDependencies.taskStore.read.mockResolvedValue(null);
-            await expect(backlogAdapter.resumeTask('nonexistent-task', 'human:ops-lead'))
-                .rejects.toThrow('RecordNotFoundError: Task not found: nonexistent-task');
-        });
-        it('[EARS-40A] should throw error when task is not in paused state for resume', async () => {
-            const activeTask = createMockTaskRecord({
-                id: '1757687335-task-active',
-                status: 'active'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(activeTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:ops-lead',
-                type: 'human',
-                displayName: 'Ops Lead',
-                publicKey: 'mock-key',
-                roles: ['resumer'],
-                status: 'active'
-            });
-            await expect(backlogAdapter.resumeTask('1757687335-task-active', 'human:ops-lead'))
-                .rejects.toThrow(`ProtocolViolationError: Task is in 'active' state. Cannot resume (requires paused).`);
-        });
-        it('[EARS-41A] should throw error when paused task has blocking feedbacks', async () => {
-            const pausedTask = createMockTaskRecord({
-                id: '1757687335-task-blocked',
-                status: 'paused'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(pausedTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:ops-lead',
-                type: 'human',
-                displayName: 'Ops Lead',
-                publicKey: 'mock-key',
-                roles: ['resumer'],
-                status: 'active'
-            });
-            mockDependencies.metricsAdapter.getTaskHealth.mockResolvedValue({
-                taskId: '1757687335-task-blocked',
-                healthScore: 60,
-                timeInCurrentStage: 5,
-                stalenessIndex: 2,
-                blockingFeedbacks: 2,
-                lastActivity: Date.now(),
-                recommendations: ['Resolve blocking feedbacks']
-            });
-            await expect(backlogAdapter.resumeTask('1757687335-task-blocked', 'human:ops-lead'))
-                .rejects.toThrow('BlockingFeedbackError: Task has blocking feedbacks. Resolve them before resuming or use force.');
-        });
-        it('[EARS-42A] should force resume ignoring blocking feedbacks with force true', async () => {
-            const taskId = '1757687335-task-force-resume';
-            const pausedTask = createMockTaskRecord({
-                id: taskId,
-                status: 'paused'
-            });
-            const activeTask = createMockTaskRecord({
-                id: taskId,
-                status: 'active'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(pausedTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:ops-lead',
-                type: 'human',
-                displayName: 'Ops Lead',
-                publicKey: 'mock-key',
-                roles: ['resumer'],
-                status: 'active'
-            });
-            mockDependencies.metricsAdapter.getTaskHealth.mockClear();
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'active',
-                conditions: {}
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue({
-                ...pausedTask,
-                payload: activeTask.payload
-            });
-            const result = await backlogAdapter.resumeTask(taskId, 'human:ops-lead', true);
-            expect(mockDependencies.metricsAdapter.getTaskHealth).not.toHaveBeenCalled();
-            expect(mockDependencies.identity.signRecord).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({ status: 'active' })
-            }), 'human:ops-lead', 'resumer');
-            expect(mockDependencies.taskStore.write).toHaveBeenCalled();
-            expect(mockDependencies.eventBus.publish).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    taskId,
-                    oldStatus: 'paused',
-                    newStatus: 'active'
-                })
-            }));
-            expect(result.status).toBe('active');
-        });
-        it('[EARS-31A] should complete task from active to done with approver quality validation', async () => {
-            const taskId = '1757687335-task-active-task';
-            const activeTask = createMockTaskRecord({
-                id: taskId,
-                status: 'active'
-            });
-            const doneTask = createMockTaskRecord({
-                id: taskId,
-                status: 'done'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(activeTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:qa-lead',
-                type: 'human',
-                displayName: 'QA Lead',
-                publicKey: 'mock-key',
-                roles: ['approver:quality'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'done',
-                conditions: { signatures: { __default__: { role: 'approver', capability_roles: ['approver:quality'], min_approvals: 1 } } }
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue(doneTask);
-            const result = await backlogAdapter.completeTask(taskId, 'human:qa-lead');
-            expect(result.status).toBe('done');
-            expect(mockDependencies.taskStore.write).toHaveBeenCalledWith(doneTask);
-            expect(mockDependencies.eventBus.publish).toHaveBeenCalledWith({
-                type: 'task.status.changed',
-                timestamp: expect.any(Number),
-                source: 'backlog_adapter',
-                payload: {
-                    taskId,
-                    oldStatus: 'active',
-                    newStatus: 'done',
-                    actorId: 'human:qa-lead'
-                }
-            });
-        });
-        it('[EARS-32A] should throw error when task not found for completion', async () => {
-            mockDependencies.taskStore.read.mockResolvedValue(null);
-            await expect(backlogAdapter.completeTask('non-existent-task', 'human:qa-lead'))
-                .rejects.toThrow('RecordNotFoundError: Task not found: non-existent-task');
-        });
-        it('[EARS-33A] should throw error when task is not in active state for completion', async () => {
-            const readyTask = createMockTaskRecord({
-                id: '1757687335-task-ready',
-                status: 'ready'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(readyTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:qa-lead',
-                type: 'human',
-                displayName: 'QA Lead',
-                publicKey: 'mock-key',
-                roles: ['approver:quality'],
-                status: 'active'
-            });
-            await expect(backlogAdapter.completeTask('1757687335-task-ready', 'human:qa-lead'))
-                .rejects.toThrow('ProtocolViolationError: Task is in \'ready\' state. Cannot complete from this state.');
-        });
-        it('[EARS-34A] should throw error when workflow methodology rejects completion', async () => {
-            const activeTask = createMockTaskRecord({
-                id: '1757687335-task-active',
-                status: 'active'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(activeTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:qa-lead',
-                type: 'human',
-                displayName: 'QA Lead',
-                publicKey: 'mock-key',
-                roles: ['approver:quality'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue(null);
-            await expect(backlogAdapter.completeTask('1757687335-task-active', 'human:qa-lead'))
-                .rejects.toThrow('ProtocolViolationError: Workflow methodology rejected active→done transition');
-        });
-        it('[EARS-28] should cancel task from ready to discarded with proper validation', async () => {
-            const taskId = '1757687335-task-ready-to-cancel';
-            const readyTask = createMockTaskRecord({
-                id: taskId,
-                status: 'ready',
-                title: 'Task to Cancel'
-            });
-            const cancelledTask = createMockTaskRecord({
-                id: taskId,
-                status: 'discarded',
-                title: 'Task to Cancel',
-                notes: '[CANCELLED] No longer needed (2025-01-15T10:30:00.000Z)'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(readyTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:product-manager',
-                type: 'human',
-                displayName: 'Product Manager',
-                publicKey: 'mock-key',
-                roles: ['approver:product'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'discarded',
-                conditions: { command: 'gitgov task cancel' }
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue(cancelledTask);
-            const result = await backlogAdapter.discardTask(taskId, 'human:product-manager', 'No longer needed');
-            expect(mockDependencies.taskStore.write).toHaveBeenCalled();
-            expect(result.status).toBe('discarded');
-            expect(result.notes).toContain('[CANCELLED] No longer needed');
-        });
-        it('[EARS-29] should cancel task from active to discarded', async () => {
-            const taskId = '1757687335-task-active-to-cancel';
-            const activeTask = createMockTaskRecord({
-                id: taskId,
-                status: 'active',
-                title: 'Active Task to Cancel'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(activeTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:team-lead',
-                type: 'human',
-                displayName: 'Team Lead',
-                publicKey: 'mock-key',
-                roles: ['approver:quality'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'discarded',
-                conditions: { command: 'gitgov task cancel' }
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue({
-                ...activeTask,
-                payload: { ...activeTask.payload, status: 'discarded' }
-            });
-            const result = await backlogAdapter.discardTask(taskId, 'human:team-lead');
-            expect(result.status).toBe('discarded');
-            expect(mockDependencies.taskStore.write).toHaveBeenCalled();
-        });
-        it('[EARS-30] should throw error when cancelling task from invalid state', async () => {
-            const draftTask = createMockTaskRecord({
-                id: '1757687335-task-draft',
-                status: 'draft'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(draftTask);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:anyone',
-                type: 'human',
-                displayName: 'Anyone',
-                publicKey: 'mock-key',
-                roles: ['author'],
-                status: 'active'
-            });
-            await expect(backlogAdapter.discardTask('1757687335-task-draft', 'human:anyone'))
-                .rejects.toThrow('ProtocolViolationError: Task is in \'draft\' state. Cannot cancel from this state. Only \'ready\', \'active\', and \'review\' tasks can be cancelled.');
-        });
-        it('[EARS-31B] should reject task from review to discarded with reason', async () => {
-            const taskId = '1757687335-task-review-to-reject';
-            const reviewTask = createMockTaskRecord({
-                id: taskId,
-                status: 'review',
-                title: 'Review Task to Reject',
-                notes: 'Original task notes'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(reviewTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:reviewer',
-                type: 'human',
-                displayName: 'Reviewer',
-                publicKey: 'mock-key',
-                roles: ['approver:product'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'discarded',
-                conditions: { command: 'gitgov task reject' }
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue({
-                ...reviewTask,
-                payload: { ...reviewTask.payload, status: 'discarded' }
-            });
-            const result = await backlogAdapter.discardTask(taskId, 'human:reviewer', 'Requirements unclear');
-            expect(result.status).toBe('discarded');
-            expect(result.notes).toContain('[REJECTED] Requirements unclear');
-            expect(result.notes).toContain('Original task notes');
-            expect(mockDependencies.taskStore.write).toHaveBeenCalled();
-        });
-        it('[EARS-32B] should add reason with REJECTED prefix in notes for reject', async () => {
-            const taskId = '1757687335-task-review-rejected';
-            const reviewTask = createMockTaskRecord({
-                id: taskId,
-                status: 'review',
-                title: 'Review Task for Rejection'
-                // notes omitted - will be undefined by default
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(reviewTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:reviewer',
-                type: 'human',
-                displayName: 'Reviewer',
-                publicKey: 'mock-key',
-                roles: ['approver:quality'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'discarded',
-                conditions: { command: 'gitgov task reject' }
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue({
-                ...reviewTask,
-                payload: { ...reviewTask.payload, status: 'discarded' }
-            });
-            const result = await backlogAdapter.discardTask(taskId, 'human:reviewer', 'Not aligned with architecture');
-            expect(result.status).toBe('discarded');
-            expect(result.notes).toContain('[REJECTED] Not aligned with architecture');
-            expect(result.notes).toContain('[REJECTED]');
-            expect(result.notes).not.toContain('[CANCELLED]');
-            expect(result.notes).toMatch(/\[REJECTED\] Not aligned with architecture \(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\)/);
-        });
-        it('[EARS-33B] should validate ready active review states for cancel reject', async () => {
-            // Test ready state (should use [CANCELLED])
-            const readyTask = createMockTaskRecord({
-                id: '1757687335-task-ready',
-                status: 'ready'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(readyTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:pm',
-                type: 'human',
-                displayName: 'PM',
-                publicKey: 'mock-key',
-                roles: ['approver:product'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'discarded',
-                conditions: { command: 'gitgov task cancel' }
-            });
-            mockDependencies.identity.signRecord.mockResolvedValue({
-                ...readyTask,
-                payload: { ...readyTask.payload, status: 'discarded' }
-            });
-            const readyResult = await backlogAdapter.discardTask('1757687335-task-ready', 'human:pm', 'Priorities changed');
-            expect(readyResult.notes).toContain('[CANCELLED] Priorities changed');
-            // Test review state (should use [REJECTED])
-            const reviewTask = createMockTaskRecord({
-                id: '1757687335-task-review',
-                status: 'review'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(reviewTask);
-            const reviewResult = await backlogAdapter.discardTask('1757687335-task-review', 'human:pm', 'Requirements unclear');
-            expect(reviewResult.notes).toContain('[REJECTED] Requirements unclear');
-        });
-    });
-    describe('Event Handlers', () => {
-        it('[EARS-31] should pause active task when blocking feedback created', async () => {
-            const taskId = '1757687335-task-active-task';
-            const mockTask = createMockTaskRecord({
-                id: taskId,
-                status: 'active'
-            });
-            const mockFeedback = {
-                id: '1757687335-feedback-blocking',
-                payload: {
-                    entityId: taskId,
-                    type: 'blocking'
-                }
-            };
-            mockDependencies.feedbackStore.read.mockResolvedValue(mockFeedback);
-            mockDependencies.taskStore.read.mockResolvedValue(mockTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            const event = {
-                type: 'feedback.created',
-                timestamp: Date.now(),
-                source: 'feedback_adapter',
-                payload: {
-                    feedbackId: '1757687335-feedback-blocking',
-                    entityType: 'task',
-                    entityId: taskId,
-                    type: 'blocking',
-                    status: 'open',
-                    content: 'Blocking feedback content',
-                    triggeredBy: 'human:reviewer'
-                }
-            };
-            await backlogAdapter.handleFeedbackCreated(event);
-            expect(mockDependencies.taskStore.write).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    status: 'paused'
-                })
-            }));
-            expect(mockDependencies.eventBus.publish).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'task.status.changed',
-                payload: expect.objectContaining({
-                    oldStatus: 'active',
-                    newStatus: 'paused'
-                })
-            }));
-        });
-        it('[EARS-33] should resume task when last blocking feedback resolved', async () => {
-            const taskId = '1757687335-task-paused-task';
-            const mockTask = createMockTaskRecord({
-                id: taskId,
-                status: 'paused'
-            });
-            const mockFeedback = {
-                id: '1757687335-feedback-resolved',
-                payload: {
-                    entityId: taskId,
-                    type: 'blocking'
-                }
-            };
-            mockDependencies.feedbackStore.read.mockResolvedValue(mockFeedback);
-            mockDependencies.taskStore.read.mockResolvedValue(mockTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.metricsAdapter.getTaskHealth.mockResolvedValue({
-                taskId: 'task-123',
-                healthScore: 100,
-                timeInCurrentStage: 0,
-                stalenessIndex: 0,
-                blockingFeedbacks: 0,
-                lastActivity: Date.now(),
-                recommendations: []
-            });
-            const event = {
-                type: 'feedback.status.changed',
-                timestamp: Date.now(),
-                source: 'feedback_adapter',
-                payload: {
-                    feedbackId: '1757687335-feedback-resolved',
-                    oldStatus: 'open',
-                    newStatus: 'resolved',
-                    triggeredBy: 'human:resolver'
-                }
-            };
-            await backlogAdapter.handleFeedbackResolved(event);
-            expect(mockDependencies.taskStore.write).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    status: 'active'
-                })
-            }));
-        });
-        it('[EARS-34] should not resume task if other blocking feedbacks remain', async () => {
-            const taskId = '1757687335-task-still-blocked';
-            const mockTask = createMockTaskRecord({
-                id: taskId,
-                status: 'paused'
-            });
-            const mockFeedback = {
-                id: '1757687335-feedback-resolved',
-                payload: {
-                    entityId: taskId,
-                    type: 'blocking'
-                }
-            };
-            mockDependencies.feedbackStore.read.mockResolvedValue(mockFeedback);
-            mockDependencies.taskStore.read.mockResolvedValue(mockTask);
-            mockDependencies.metricsAdapter.getTaskHealth.mockResolvedValue({
-                taskId: 'task-123',
-                healthScore: 80,
-                timeInCurrentStage: 0,
-                stalenessIndex: 0,
-                blockingFeedbacks: 1,
-                lastActivity: Date.now(),
-                recommendations: []
-            });
-            const event = {
-                type: 'feedback.status.changed',
-                timestamp: Date.now(),
-                source: 'feedback_adapter',
-                payload: {
-                    feedbackId: '1757687335-feedback-resolved',
-                    oldStatus: 'open',
-                    newStatus: 'resolved',
-                    triggeredBy: 'human:resolver'
-                }
-            };
-            await backlogAdapter.handleFeedbackResolved(event);
-            // Should not write to taskStore (no status change)
-            expect(mockDependencies.taskStore.write).not.toHaveBeenCalled();
-        });
-        it('[EARS-35] should transition task to active on first execution', async () => {
-            const taskId = '1757687335-task-ready-task';
-            const mockTask = createMockTaskRecord({
-                id: taskId,
-                status: 'ready'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(mockTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:executor',
-                type: 'human',
-                displayName: 'Executor',
-                publicKey: 'mock-key',
-                roles: ['executor'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'active',
-                conditions: {}
-            });
-            const event = {
-                type: 'execution.created',
-                timestamp: Date.now(),
-                source: 'execution_adapter',
-                payload: {
-                    executionId: '1757687335-exec-first',
-                    taskId,
-                    triggeredBy: 'human:executor',
-                    isFirstExecution: true
-                }
-            };
-            await backlogAdapter.handleExecutionCreated(event);
-            expect(mockDependencies.taskStore.write).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    status: 'active'
-                })
-            }));
-        });
-        it('[EARS-36] should do nothing on subsequent executions', async () => {
-            const event = {
-                type: 'execution.created',
-                timestamp: Date.now(),
-                source: 'execution_adapter',
-                payload: {
-                    executionId: '1757687335-exec-second',
-                    taskId: '1757687335-task-active-task',
-                    triggeredBy: 'human:executor',
-                    isFirstExecution: false
-                }
-            };
-            await backlogAdapter.handleExecutionCreated(event);
-            // Should not write to taskStore
-            expect(mockDependencies.taskStore.write).not.toHaveBeenCalled();
-        });
-        it('[EARS-37] should archive task when changelog created', async () => {
-            const taskId = '1757687335-task-done-task';
-            const mockTask = createMockTaskRecord({
-                id: taskId,
-                status: 'done'
-            });
-            const mockChangelog = {
-                id: '1757687335-changelog-task-done',
-                payload: {
-                    entityType: 'task',
-                    entityId: taskId
-                }
-            };
-            mockDependencies.changelogStore.read.mockResolvedValue(mockChangelog);
-            mockDependencies.taskStore.read.mockResolvedValue(mockTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            const event = {
-                type: 'changelog.created',
-                timestamp: Date.now(),
-                source: 'changelog_adapter',
-                payload: {
-                    changelogId: '1757687335-changelog-task-done',
-                    entityId: taskId,
-                    entityType: 'task',
-                    changeType: 'completion',
-                    riskLevel: 'low',
-                    triggeredBy: 'system',
-                    title: 'Task completed',
-                    trigger: 'manual'
-                }
-            };
-            await backlogAdapter.handleChangelogCreated(event);
-            expect(mockDependencies.taskStore.write).toHaveBeenCalledWith(expect.objectContaining({
-                payload: expect.objectContaining({
-                    status: 'archived'
-                })
-            }));
-        });
-        it('[EARS-45] should complete parent cycle when all child cycles are completed', async () => {
-            const parentCycleId = '1757687335-cycle-parent';
-            const childCycleId = '1757687335-cycle-child';
-            // Mock parent cycle with child
-            const parentCycle = createMockCycleRecord({
-                id: parentCycleId,
-                status: 'active',
-                childCycleIds: [childCycleId]
-            });
-            // Mock completed child cycle
-            const childCycle = createMockCycleRecord({
-                id: childCycleId,
-                status: 'completed'
-            });
-            // Setup mocks
-            mockDependencies.cycleStore.read
-                .mockImplementation(async (id) => {
-                if (id === childCycleId)
-                    return childCycle;
-                if (id === parentCycleId)
-                    return parentCycle;
-                return null;
-            });
-            mockDependencies.cycleStore.list.mockResolvedValue([parentCycleId, childCycleId]);
-            mockDependencies.cycleStore.write.mockResolvedValue(undefined);
-            const event = {
-                type: 'cycle.status.changed',
-                timestamp: Date.now(),
-                source: 'backlog_adapter',
-                payload: {
-                    cycleId: childCycleId,
-                    oldStatus: 'active',
-                    newStatus: 'completed',
-                    triggeredBy: 'system'
-                }
-            };
-            // For now, just verify it doesn't throw an error
-            // The full implementation requires complex factory mocking
-            await expect(backlogAdapter.handleCycleStatusChanged(event)).resolves.not.toThrow();
-            // Note: Epic task completion is delegated to planning methodology (not implemented yet)
-        });
-    });
-    describe('Performance Benchmarks', () => {
-        it('[EARS-44] should execute task operations in under 100ms', async () => {
-            const mockTask = createMockTaskRecord({
-                id: '1757687335-task-performance',
-                title: 'Performance Test Task',
-                status: 'draft'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(mockTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            mockDependencies.identity.getActor.mockResolvedValue({
-                id: 'human:performer',
-                type: 'human',
-                displayName: 'Performer',
-                publicKey: 'mock-key',
-                roles: ['author'],
-                status: 'active'
-            });
-            mockDependencies.workflowMethodologyAdapter.getTransitionRule.mockResolvedValue({
-                to: 'review',
-                conditions: {}
-            });
-            const startTime = Date.now();
-            await backlogAdapter.submitTask('1757687335-task-performance', 'human:performer');
-            const endTime = Date.now();
-            expect(endTime - startTime).toBeLessThan(100); // Performance target <100ms
-        });
-        it('[EARS-44] should execute cycle operations in under 100ms', async () => {
-            const mockCycle = createMockCycleRecord({
-                id: '1757687335-cycle-performance',
-                title: 'Performance Test Cycle',
-                status: 'planning'
-            });
-            const { createCycleRecord } = require('../../factories/cycle_factory');
-            createCycleRecord.mockResolvedValue(mockCycle.payload);
-            mockDependencies.identity.signRecord.mockResolvedValue(mockCycle);
-            mockDependencies.cycleStore.write.mockResolvedValue(undefined);
-            const startTime = Date.now();
-            await backlogAdapter.createCycle({
-                title: 'Performance Test Cycle',
-                status: 'planning'
-            }, 'human:performer');
-            const endTime = Date.now();
-            expect(endTime - startTime).toBeLessThan(100); // Performance target <100ms
-        });
-        it('[EARS-44] should execute getSystemStatus in under 100ms', async () => {
-            const startTime = Date.now();
-            await backlogAdapter.getSystemStatus();
-            const endTime = Date.now();
-            expect(endTime - startTime).toBeLessThan(100); // Performance target <100ms
-            expect(mockDependencies.metricsAdapter.getSystemStatus).toHaveBeenCalled();
-        });
-        it('[EARS-44] should execute getTaskHealth in under 100ms', async () => {
-            const startTime = Date.now();
-            await backlogAdapter.getTaskHealth('1757687335-task-health-test');
-            const endTime = Date.now();
-            expect(endTime - startTime).toBeLessThan(100); // Performance target <100ms
-            expect(mockDependencies.metricsAdapter.getTaskHealth).toHaveBeenCalledWith('1757687335-task-health-test');
-        });
-    });
-    describe('Agent Navigation', () => {
-        it('[EARS-48] should return tasks assigned to a specific actor', async () => {
-            const taskId1 = '1757687335-task-assigned-1';
-            const taskId2 = '1757687335-task-assigned-2';
-            const taskId3 = '1757687335-task-unassigned';
-            const actorId = 'human:developer';
-            // Mock feedback records for assignments
-            const assignmentFeedback1 = {
-                id: '1757687335-feedback-assignment-1',
-                payload: {
-                    entityId: taskId1,
-                    type: 'assignment',
-                    assignee: actorId,
-                    status: 'resolved'
-                }
-            };
-            const assignmentFeedback2 = {
-                id: '1757687335-feedback-assignment-2',
-                payload: {
-                    entityId: taskId2,
-                    type: 'assignment',
-                    assignee: actorId,
-                    status: 'resolved'
-                }
-            };
-            const nonAssignmentFeedback = {
-                id: '1757687335-feedback-suggestion',
-                payload: {
-                    entityId: taskId3,
-                    type: 'suggestion',
-                    assignee: 'human:other',
-                    status: 'open'
-                }
-            };
-            // Mock tasks
-            const task1 = createMockTaskRecord({ id: taskId1, title: 'Assigned Task 1' });
-            const task2 = createMockTaskRecord({ id: taskId2, title: 'Assigned Task 2' });
-            // Setup mocks
-            mockDependencies.feedbackStore.list.mockResolvedValue([
-                createMockFeedbackRecord({ id: '1757687335-feedback-assignment-1' }),
-                createMockFeedbackRecord({ id: '1757687335-feedback-assignment-2' }),
-                createMockFeedbackRecord({ id: '1757687335-feedback-suggestion' })
-            ]);
-            mockDependencies.feedbackStore.read
-                .mockResolvedValueOnce(assignmentFeedback1)
-                .mockResolvedValueOnce(assignmentFeedback2)
-                .mockResolvedValueOnce(nonAssignmentFeedback);
-            mockDependencies.taskStore.read
-                .mockResolvedValueOnce(task1)
-                .mockResolvedValueOnce(task2);
-            const result = await backlogAdapter.getTasksAssignedToActor(actorId);
-            expect(result).toHaveLength(2);
-            expect(result[0]?.id).toBe(taskId1);
-            expect(result[1]?.id).toBe(taskId2);
-        });
-        it('[EARS-49] should return empty array for actor with no assigned tasks', async () => {
-            const actorId = 'human:unassigned';
-            // Mock no assignment feedbacks for this actor
-            const nonAssignmentFeedback = {
-                id: '1757687335-feedback-other',
-                payload: {
-                    entityId: 'task-123',
-                    type: 'suggestion',
-                    assignee: 'human:other-actor',
-                    status: 'open'
-                }
-            };
-            mockDependencies.feedbackStore.list.mockResolvedValue([
-                createMockFeedbackRecord({ id: '1757687335-feedback-other' })
-            ]);
-            mockDependencies.feedbackStore.read.mockResolvedValue(nonAssignmentFeedback);
-            const result = await backlogAdapter.getTasksAssignedToActor(actorId);
-            expect(result).toEqual([]);
-        });
-    });
-    describe('Future Methods (Not Implemented)', () => {
-        it('[EARS-38] should throw NotImplementedError for lint method', async () => {
-            await expect(backlogAdapter.lint())
-                .rejects.toThrow('NotImplementedError: lint() will be implemented when lint_command.md is ready');
-        });
-        it('[EARS-39] should throw NotImplementedError for audit method', async () => {
-            await expect(backlogAdapter.audit())
-                .rejects.toThrow('NotImplementedError: audit() will be implemented when audit_command.md is ready');
-        });
-        it('[EARS-42] should throw NotImplementedError for processChanges method', async () => {
-            await expect(backlogAdapter.processChanges([]))
-                .rejects.toThrow('NotImplementedError: processChanges() will be implemented when commit_processor.md is ready');
-        });
-    });
-    describe('Error Handling & Edge Cases', () => {
-        it('[EARS-45] should handle adapter failures gracefully in event handlers', async () => {
-            // Simulate adapter failure
-            mockDependencies.feedbackStore.read.mockRejectedValue(new Error('Store failure'));
-            const event = {
-                type: 'feedback.created',
-                timestamp: Date.now(),
-                source: 'feedback_adapter',
-                payload: {
-                    feedbackId: '1757687335-feedback-error',
-                    entityType: 'task',
-                    entityId: '1757687335-task-error',
-                    type: 'blocking',
-                    status: 'open',
-                    content: 'Error feedback content',
-                    triggeredBy: 'human:reviewer'
-                }
-            };
-            // Should not throw error - graceful degradation
-            await expect(backlogAdapter.handleFeedbackCreated(event)).resolves.not.toThrow();
-        });
-        it('[EARS-27] should re-validate full payload using factory', async () => {
-            const originalTask = createMockTaskRecord({
-                id: '1757687335-task-validation',
-                title: 'Original Title',
-                status: 'draft'
-            });
-            mockDependencies.taskStore.read.mockResolvedValue(originalTask);
-            mockDependencies.taskStore.write.mockResolvedValue(undefined);
-            // Mock factory to validate the merged payload
-            const { createTaskRecord } = require('../../factories/task_factory');
-            createTaskRecord.mockResolvedValue({
-                ...originalTask.payload,
-                title: 'Updated Title'
-            });
-            await backlogAdapter.updateTask('1757687335-task-validation', { title: 'Updated Title' });
-            // Verify factory was called with merged payload
-            expect(createTaskRecord).toHaveBeenCalledWith({
-                ...originalTask.payload,
-                title: 'Updated Title'
-            });
-        });
-    });
-});
-//# sourceMappingURL=backlog_adapter.test.js.map