specforge-mcp 0.12.0 → 0.13.0

package/dist/tools/orchestrate.test.js

@@ -1,1117 +0,0 @@
-// Tests for handleOrchestrate
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../storage/base-store.js', () => ({
-    readJson: vi.fn(),
-    writeJson: vi.fn(),
-    projectDataDir: (projectId) => `data/projects/${projectId}`,
-}));
-vi.mock('../storage/index.js', () => ({
-    specStore: { listSpecs: vi.fn() },
-}));
-vi.mock('node:crypto', () => ({
-    randomUUID: () => 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
-}));
-import { handleOrchestrate } from './orchestrate.js';
-import { readJson, writeJson } from '../storage/base-store.js';
-import { specStore } from '../storage/index.js';
-const mockReadJson = vi.mocked(readJson);
-const mockWriteJson = vi.mocked(writeJson);
-const mockListSpecs = vi.mocked(specStore.listSpecs);
-function emptyState() {
-    return { sessions: [], locks: [], conflicts: [] };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockWriteJson.mockResolvedValue(undefined);
-});
-describe('handleOrchestrate', () => {
-    // === register ===
-    it('should register a new agent session', async () => {
-        mockReadJson.mockResolvedValue(emptyState());
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'register',
-        });
-        expect(result.isError).toBeUndefined();
-        const data = JSON.parse(result.content[0].text);
-        expect(data.action).toBe('register');
-        expect(data.sessionId).toBeDefined();
-        expect(data.sessions).toHaveLength(1);
-        expect(mockWriteJson).toHaveBeenCalled();
-    });
-    it('should register with custom sessionId and specId', async () => {
-        mockReadJson.mockResolvedValue(emptyState());
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'register',
-            sessionId: 'my-agent',
-            specId: 'SPEC-001',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.sessionId).toBe('my-agent');
-        expect(data.sessions[0].activeSpecs).toContain('SPEC-001');
-    });
-    it('should re-activate existing session', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: '2025-01-01T00:00:00Z',
-                    status: 'disconnected',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'register',
-            sessionId: 'agent-1',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.message).toContain('Re-activated');
-    });
-    it('should detect spec overlap conflict on register', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'register',
-            sessionId: 'agent-2',
-            specId: 'SPEC-001',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.conflicts).toBeDefined();
-        expect(data.conflicts).toHaveLength(1);
-        expect(data.conflicts[0].type).toBe('spec-overlap');
-    });
-    // === heartbeat ===
-    it('should error when heartbeat called without sessionId', async () => {
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'heartbeat',
-        });
-        expect(result.isError).toBe(true);
-    });
-    it('should error when heartbeat for unknown session', async () => {
-        mockReadJson.mockResolvedValue(emptyState());
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'heartbeat',
-            sessionId: 'unknown',
-        });
-        expect(result.isError).toBe(true);
-    });
-    it('should update heartbeat successfully', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: '2025-01-01T00:00:00Z',
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'heartbeat',
-            sessionId: 'agent-1',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.action).toBe('heartbeat');
-        expect(data.message).toContain('Heartbeat received');
-    });
-    // === lock ===
-    it('should error when lock called without sessionId', async () => {
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            resourcePath: 'src/auth.ts',
-        });
-        expect(result.isError).toBe(true);
-    });
-    it('should error when lock called without resource', async () => {
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'agent-1',
-        });
-        expect(result.isError).toBe(true);
-    });
-    it('should lock a resource', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'agent-1',
-            resourcePath: 'src/auth.ts',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.granted).toBe(true);
-    });
-    it('should deny lock when resource locked by another', async () => {
-        const future = new Date(Date.now() + 3600000).toISOString();
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [{
-                    type: 'file',
-                    resourceId: 'src/auth.ts',
-                    lockedBy: 'agent-2',
-                    lockedAt: new Date().toISOString(),
-                    reason: 'Working',
-                    expiresAt: future,
-                }],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'agent-1',
-            resourcePath: 'src/auth.ts',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.granted).toBe(false);
-    });
-    // === unlock ===
-    it('should error when unlock called without sessionId', async () => {
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'unlock',
-            resourcePath: 'src/auth.ts',
-        });
-        expect(result.isError).toBe(true);
-    });
-    it('should unlock a resource', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [{ resourceId: 'src/auth.ts' }],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [{
-                    type: 'file',
-                    resourceId: 'src/auth.ts',
-                    lockedBy: 'agent-1',
-                    lockedAt: new Date().toISOString(),
-                    reason: 'Working',
-                }],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'unlock',
-            sessionId: 'agent-1',
-            resourcePath: 'src/auth.ts',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.granted).toBe(true);
-    });
-    // === distribute ===
-    it('should distribute tasks with no active sessions', async () => {
-        mockReadJson.mockResolvedValue(emptyState());
-        mockListSpecs.mockResolvedValue([]);
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'distribute',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.action).toBe('distribute');
-        expect(data.message).toContain('No active agent sessions');
-    });
-    it('should distribute tasks across active agents', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        mockListSpecs.mockResolvedValue([
-            {
-                id: 'SPEC-001',
-                status: 'implementing',
-                risk: 'high',
-                scope: 'feature',
-                estimation: { devHours: 8 },
-                dependencies: [],
-            },
-            {
-                id: 'SPEC-002',
-                status: 'approved',
-                risk: 'low',
-                scope: 'trivial',
-                estimation: { devHours: 2 },
-                dependencies: [],
-            },
-        ]);
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'distribute',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.distribution.length).toBe(2);
-    });
-    // === status ===
-    it('should return orchestration status', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'status',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.action).toBe('status');
-        expect(data.activeSessions).toBe(1);
-    });
-    // === resolve-conflict ===
-    it('should resolve conflicts', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [],
-            locks: [],
-            conflicts: [{
-                    type: 'spec-overlap',
-                    agents: ['agent-1', 'agent-2'],
-                    resource: 'SPEC-001',
-                    resolution: 'Coordinate',
-                    severity: 'warning',
-                }],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'resolve-conflict',
-            sessionId: 'agent-1',
-            specId: 'SPEC-001',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.action).toBe('resolve-conflict');
-        expect(data.message).toContain('Resolved');
-    });
-    // === unknown action ===
-    it('should error for unknown action', async () => {
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'unknown',
-        });
-        expect(result.isError).toBe(true);
-    });
-    // === error handling ===
-    it('should catch and return general errors', async () => {
-        mockReadJson.mockRejectedValue(new Error('Disk full'));
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'status',
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain('Disk full');
-    });
-    // --- Coverage for non-Error thrown (line 721) ---
-    it('should catch non-Error thrown values', async () => {
-        mockReadJson.mockRejectedValue('string error');
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'register',
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain('string error');
-    });
-    // --- Coverage for resolve-conflict with force-unlock (lines 638-652) ---
-    it('should force-unlock resource when resolving conflict', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [
-                {
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001'],
-                    lockedResources: [{ resourceId: 'SPEC-001', type: 'spec', lockedBy: 'agent-1' }],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                },
-                {
-                    sessionId: 'agent-2',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                },
-            ],
-            locks: [{
-                    type: 'spec',
-                    resourceId: 'SPEC-001',
-                    lockedBy: 'agent-1',
-                    lockedAt: new Date().toISOString(),
-                    reason: 'Working',
-                    expiresAt: new Date(Date.now() + 3600000).toISOString(),
-                }],
-            conflicts: [{
-                    type: 'spec-overlap',
-                    agents: ['agent-1', 'agent-2'],
-                    resource: 'SPEC-001',
-                    resolution: 'Coordinate',
-                    severity: 'warning',
-                }],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'resolve-conflict',
-            sessionId: 'agent-2',
-            specId: 'SPEC-001',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.message).toContain('Resolved');
-        // Lock should have been force-removed from agent-1
-        const savedState = mockWriteJson.mock.calls[0][1];
-        expect(savedState.locks).toHaveLength(0);
-    });
-    // --- Coverage for resolve-conflict with no matching conflicts ---
-    it('should report no matching conflicts when none found', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [],
-            locks: [],
-            conflicts: [{
-                    type: 'spec-overlap',
-                    agents: ['agent-3', 'agent-4'],
-                    resource: 'SPEC-002',
-                    resolution: 'Coordinate',
-                    severity: 'warning',
-                }],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'resolve-conflict',
-            sessionId: 'agent-1',
-            specId: 'SPEC-001',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.message).toContain('No matching conflicts');
-    });
-    // --- Coverage for resolve-conflict without sessionId or resourcePath ---
-    it('should resolve all conflicts when no filters provided', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [],
-            locks: [],
-            conflicts: [
-                {
-                    type: 'spec-overlap',
-                    agents: ['agent-1', 'agent-2'],
-                    resource: 'SPEC-001',
-                    resolution: 'Coordinate',
-                    severity: 'warning',
-                },
-                {
-                    type: 'spec-overlap',
-                    agents: ['agent-3', 'agent-4'],
-                    resource: 'SPEC-002',
-                    resolution: 'Coordinate',
-                    severity: 'warning',
-                },
-            ],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'resolve-conflict',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.message).toContain('Resolved 2 conflict(s)');
-    });
-    // --- Coverage for unlock with no resource (specId or resourcePath) ---
-    it('should error when unlock called without resourcePath or specId', async () => {
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'unlock',
-            sessionId: 'agent-1',
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain('resourcePath or specId');
-    });
-    // --- Coverage for unlock: lock not found ---
-    it('should error when trying to unlock a resource not locked by session', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'unlock',
-            sessionId: 'agent-1',
-            resourcePath: 'src/not-locked.ts',
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain('No lock on');
-    });
-    // --- Coverage for lock: session not found ---
-    it('should error when locking with non-existent session', async () => {
-        mockReadJson.mockResolvedValue(emptyState());
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'unknown-agent',
-            resourcePath: 'src/auth.ts',
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain('not found');
-    });
-    // --- Coverage for lock: extend existing lock by same session ---
-    it('should extend lock when same session locks same resource', async () => {
-        const future = new Date(Date.now() + 3600000).toISOString();
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [{
-                            type: 'file',
-                            resourceId: 'src/auth.ts',
-                            lockedBy: 'agent-1',
-                            lockedAt: new Date().toISOString(),
-                            reason: 'Working',
-                            expiresAt: future,
-                        }],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [{
-                    type: 'file',
-                    resourceId: 'src/auth.ts',
-                    lockedBy: 'agent-1',
-                    lockedAt: new Date().toISOString(),
-                    reason: 'Working',
-                    expiresAt: future,
-                }],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'agent-1',
-            resourcePath: 'src/auth.ts',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.granted).toBe(true);
-        expect(data.message).toContain('extended');
-    });
-    // --- Coverage for lock using specId instead of resourcePath ---
-    it('should lock using specId as resource identifier', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'agent-1',
-            specId: 'SPEC-001',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.granted).toBe(true);
-    });
-    // --- Coverage for lock: different resource types (config, knowledge) ---
-    it('should detect config resource type for .json files', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'agent-1',
-            resourcePath: 'config/settings.json',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.granted).toBe(true);
-    });
-    it('should detect knowledge resource type', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'agent-1',
-            resourcePath: 'data/knowledge/base.json',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.granted).toBe(true);
-    });
-    // --- Coverage for pruneExpiredLocks ---
-    it('should prune expired locks from state', async () => {
-        const expiredTime = new Date(Date.now() - 3600000).toISOString();
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [{
-                            type: 'file',
-                            resourceId: 'src/old.ts',
-                            lockedBy: 'agent-1',
-                            lockedAt: '2025-01-01T00:00:00Z',
-                            reason: 'Working',
-                            expiresAt: expiredTime,
-                        }],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [{
-                    type: 'file',
-                    resourceId: 'src/old.ts',
-                    lockedBy: 'agent-1',
-                    lockedAt: '2025-01-01T00:00:00Z',
-                    reason: 'Working',
-                    expiresAt: expiredTime,
-                }],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'status',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.activeLocks).toBe(0);
-    });
-    // --- Coverage for pruneIdleSessions ---
-    it('should mark idle sessions as disconnected', async () => {
-        const veryOldTime = new Date(Date.now() - 20 * 60 * 1000).toISOString(); // 20 min ago
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: veryOldTime,
-                    status: 'active',
-                }, {
-                    sessionId: 'agent-2',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: veryOldTime,
-                    status: 'idle',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'status',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.disconnectedSessions).toBe(2);
-        expect(data.activeSessions).toBe(0);
-    });
-    // --- Coverage for isLockExpired with no expiresAt ---
-    it('should not consider lock expired when expiresAt is undefined', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [{
-                    type: 'file',
-                    resourceId: 'src/auth.ts',
-                    lockedBy: 'agent-2',
-                    lockedAt: new Date().toISOString(),
-                    reason: 'Working',
-                    // No expiresAt -> never expires
-                }],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'lock',
-            sessionId: 'agent-1',
-            resourcePath: 'src/auth.ts',
-        });
-        const data = JSON.parse(result.content[0].text);
-        // Lock should still be held by agent-2 (not expired)
-        expect(data.granted).toBe(false);
-        expect(data.message).toContain('indefinitely');
-    });
-    // --- Coverage for distribute: dependency conflicts ---
-    it('should detect dependency conflicts between agents', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [
-                {
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                },
-                {
-                    sessionId: 'agent-2',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-002'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                },
-            ],
-            locks: [],
-            conflicts: [],
-        });
-        mockListSpecs.mockResolvedValue([
-            {
-                id: 'SPEC-001',
-                status: 'implementing',
-                risk: 'medium',
-                scope: 'feature',
-                estimation: { devHours: 8 },
-                dependencies: [],
-            },
-            {
-                id: 'SPEC-002',
-                status: 'implementing',
-                risk: 'critical',
-                scope: 'architectural',
-                estimation: { devHours: 16 },
-                dependencies: ['SPEC-001'], // depends on SPEC-001
-            },
-        ]);
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'distribute',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.conflicts).toBeDefined();
-        expect(data.conflicts.length).toBeGreaterThan(0);
-        expect(data.conflicts[0].type).toBe('dependency-conflict');
-    });
-    // --- Coverage for distribute: blocked specs ---
-    it('should mark specs as blocked when dependencies not done', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        mockListSpecs.mockResolvedValue([
-            {
-                id: 'SPEC-001',
-                status: 'implementing',
-                risk: 'medium',
-                scope: 'feature',
-                estimation: { devHours: 8 },
-                dependencies: [],
-            },
-            {
-                id: 'SPEC-002',
-                status: 'approved',
-                risk: 'low',
-                scope: 'feature',
-                estimation: { devHours: 4 },
-                dependencies: ['SPEC-001'],
-            },
-        ]);
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'distribute',
-        });
-        const data = JSON.parse(result.content[0].text);
-        const blockedTask = data.distribution.find((t) => t.specId === 'SPEC-002');
-        expect(blockedTask.status).toBe('blocked');
-        expect(blockedTask.blockedBy).toContain('SPEC-001');
-    });
-    // --- Coverage for register: re-activate with new specId ---
-    it('should add specId when re-activating existing session', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: '2025-01-01T00:00:00Z',
-                    status: 'disconnected',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'register',
-            sessionId: 'agent-1',
-            specId: 'SPEC-002',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.message).toContain('Re-activated');
-        const savedState = mockWriteJson.mock.calls[0][1];
-        expect(savedState.sessions[0].activeSpecs).toContain('SPEC-002');
-    });
-    // --- Coverage for unlock using specId ---
-    it('should unlock using specId as resource identifier', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001'],
-                    lockedResources: [{ resourceId: 'SPEC-001', type: 'spec', lockedBy: 'agent-1' }],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [{
-                    type: 'spec',
-                    resourceId: 'SPEC-001',
-                    lockedBy: 'agent-1',
-                    lockedAt: new Date().toISOString(),
-                    reason: 'Working',
-                }],
-            conflicts: [],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'unlock',
-            sessionId: 'agent-1',
-            specId: 'SPEC-001',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.granted).toBe(true);
-    });
-    // --- Coverage for defensive guard: existingSession after findIndex (line 109) ---
-    it('should throw when re-activating session but indexed access returns undefined', async () => {
-        const sessions = new Proxy([], {
-            get(target, prop) {
-                if (prop === 'findIndex') {
-                    return () => 0;
-                }
-                return Reflect.get(target, prop);
-            },
-        });
-        mockReadJson.mockResolvedValue({ sessions, locks: [], conflicts: [] });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'register',
-            sessionId: 'ghost-agent',
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain('unexpectedly missing');
-    });
-    // --- Coverage for sort branch: a not blocked, b blocked -> -1 (line 524) ---
-    it('should sort blocked specs after non-blocked in distribute', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [{
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                }],
-            locks: [],
-            conflicts: [],
-        });
-        // SPEC-003 is blocked (depends on SPEC-001 which is not done)
-        // SPEC-002 is available (no deps)
-        // SPEC-001 is available (no deps)
-        // Ordering forces sort to compare blocked vs non-blocked in both directions
-        mockListSpecs.mockResolvedValue([
-            {
-                id: 'SPEC-003',
-                status: 'approved',
-                risk: 'low',
-                scope: 'feature',
-                estimation: { devHours: 2 },
-                dependencies: ['SPEC-001'],
-            },
-            {
-                id: 'SPEC-002',
-                status: 'approved',
-                risk: 'medium',
-                scope: 'feature',
-                estimation: { devHours: 4 },
-                dependencies: [],
-            },
-            {
-                id: 'SPEC-001',
-                status: 'draft',
-                risk: 'high',
-                scope: 'cross-module',
-                estimation: { devHours: 8 },
-                dependencies: [],
-            },
-        ]);
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'distribute',
-        });
-        const data = JSON.parse(result.content[0].text);
-        // Blocked items should come last
-        const lastItem = data.distribution[data.distribution.length - 1];
-        expect(lastItem.status).toBe('blocked');
-        expect(lastItem.specId).toBe('SPEC-003');
-    });
-    // --- Coverage for alreadyReported check in distribute (line 543) ---
-    it('should not duplicate dependency conflict reports between same agent pair', async () => {
-        mockReadJson.mockResolvedValue({
-            sessions: [
-                {
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-001', 'SPEC-003'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                },
-                {
-                    sessionId: 'agent-2',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: ['SPEC-002'],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                },
-            ],
-            locks: [],
-            conflicts: [],
-        });
-        // Both SPEC-002 and SPEC-003 depend on SPEC-001
-        // SPEC-002 is worked on by agent-2 and depends on SPEC-001 (agent-1) -> conflict
-        // SPEC-003 is worked on by agent-1 and depends on SPEC-001 (agent-1) -> same agent, no conflict
-        // But we need duplicate: two specs causing the same agent-pair conflict on same resource
-        // SPEC-002 depends on SPEC-001 -> conflict between agent-2 and agent-1 for resource SPEC-002
-        // SPEC-002 also depends on SPEC-003 -> conflict between agent-2 and agent-1 for resource SPEC-002 (duplicate!)
-        mockListSpecs.mockResolvedValue([
-            {
-                id: 'SPEC-001',
-                status: 'implementing',
-                risk: 'medium',
-                scope: 'feature',
-                estimation: { devHours: 8 },
-                dependencies: [],
-            },
-            {
-                id: 'SPEC-002',
-                status: 'implementing',
-                risk: 'medium',
-                scope: 'feature',
-                estimation: { devHours: 8 },
-                dependencies: ['SPEC-001', 'SPEC-003'],
-            },
-            {
-                id: 'SPEC-003',
-                status: 'implementing',
-                risk: 'medium',
-                scope: 'feature',
-                estimation: { devHours: 4 },
-                dependencies: [],
-            },
-        ]);
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'distribute',
-        });
-        const data = JSON.parse(result.content[0].text);
-        // Should have conflicts, but no duplicates for the same resource+agents combo
-        expect(data.conflicts).toBeDefined();
-        const spec002Conflicts = data.conflicts.filter((c) => c.resource === 'SPEC-002');
-        // Both dependencies (SPEC-001, SPEC-003) are on agent-1, but only 1 conflict per resource
-        expect(spec002Conflicts.length).toBeLessThanOrEqual(2);
-        // The alreadyReported check prevents duplicate agent-pair+resource combos
-        const agentPairs = spec002Conflicts.map((c) => [...c.agents].sort().join(','));
-        const uniquePairs = new Set(agentPairs);
-        expect(uniquePairs.size).toBe(agentPairs.length);
-    });
-    // --- Coverage for status with idle and disconnected sessions ---
-    it('should correctly count idle and disconnected sessions', async () => {
-        const veryOldTime = new Date(Date.now() - 20 * 60 * 1000).toISOString();
-        mockReadJson.mockResolvedValue({
-            sessions: [
-                {
-                    sessionId: 'agent-1',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: new Date().toISOString(),
-                    status: 'active',
-                },
-                {
-                    sessionId: 'agent-2',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: veryOldTime,
-                    status: 'idle',
-                },
-                {
-                    sessionId: 'agent-3',
-                    agentPlatform: 'custom',
-                    projectId: 'proj-1',
-                    activeSpecs: [],
-                    lockedResources: [],
-                    startedAt: '2025-01-01T00:00:00Z',
-                    lastActivity: '2020-01-01T00:00:00Z',
-                    status: 'disconnected',
-                },
-            ],
-            locks: [],
-            conflicts: [{
-                    type: 'spec-overlap',
-                    agents: ['agent-1', 'agent-2'],
-                    resource: 'SPEC-001',
-                    resolution: 'Coordinate',
-                    severity: 'warning',
-                }],
-        });
-        const result = await handleOrchestrate({
-            projectId: 'proj-1',
-            action: 'status',
-        });
-        const data = JSON.parse(result.content[0].text);
-        expect(data.totalSessions).toBe(3);
-        expect(data.activeSessions).toBe(1);
-        expect(data.disconnectedSessions).toBeGreaterThanOrEqual(1);
-        expect(data.unresolvedConflicts).toBe(1);
-    });
-});
-//# sourceMappingURL=orchestrate.test.js.map