specforge-mcp 0.1.0

package/dist/tools/orchestrate.test.js

@@ -0,0 +1,1117 @@
+// 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