coordinator.test.ts

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import os from 'os';
import { join, dirname } from 'path';
import { getChangedFiles, getAllFileDiffs, getDiffBaseSha } from '../ipc/git.js';

// --- fs / child_process mocks (must come before dynamic import) ---
const mockExecFile = vi.fn(
  (
    _cmd: string,
    _args: string[],
    _opts: unknown,
    cb: (err: Error | null, stdout: string, stderr: string) => void,
  ) => {
    cb(null, '', '');
  },
);

vi.mock('child_process', () => ({
  execFile: mockExecFile,
}));

const mockWriteFileSync = vi.fn();
const mockReadFileSync = vi.fn(() => '# existing\n');
const mockExistsSync = vi.fn(() => false);
const mockUnlinkSync = vi.fn();
const mockMkdirSync = vi.fn();

vi.mock('fs', () => ({
  writeFileSync: mockWriteFileSync,
  readFileSync: mockReadFileSync,
  existsSync: mockExistsSync,
  unlinkSync: mockUnlinkSync,
  mkdirSync: mockMkdirSync,
}));

// fs/promises mocks — mirror the sync mocks above
const mockFsWriteFile = vi.fn().mockResolvedValue(undefined);
const mockFsReadFile = vi.fn().mockResolvedValue('# existing\n');
const mockFsAccess = vi
  .fn()
  .mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
const mockFsUnlink = vi.fn().mockResolvedValue(undefined);
const mockFsMkdir = vi.fn().mockResolvedValue(undefined);

vi.mock('fs/promises', () => ({
  writeFile: mockFsWriteFile,
  readFile: mockFsReadFile,
  access: mockFsAccess,
  unlink: mockFsUnlink,
  mkdir: mockFsMkdir,
}));

// --- other mocks ---
const mockNotifyRenderer = vi.fn();
const mockOnPtyEvent = vi.fn();
const mockSpawnAgent = vi.fn();
const mockSubscribeToAgent = vi.fn();
const mockGetAgentScrollback = vi.fn<() => string | null>(() => null);
const mockCreateBackendTask = vi.fn().mockResolvedValue({
  id: 'task-1',
  branch_name: 'task/test',
  worktree_path: '/tmp/test',
});

const mockAtomicWriteFileSync = vi.fn();
const mockAtomicWriteFile = vi.fn().mockResolvedValue(undefined);

vi.mock('./atomic.js', () => ({
  atomicWriteFileSync: mockAtomicWriteFileSync,
  atomicWriteFile: mockAtomicWriteFile,
}));

vi.mock('./prompt-detect.js', () => ({
  stripAnsi: (s: string) => s,
  chunkContainsAgentPrompt: (s: string) => s.includes('❯'),
}));

vi.mock('../ipc/pty.js', () => ({
  spawnAgent: mockSpawnAgent,
  writeToAgent: vi.fn(),
  killAgent: vi.fn(),
  subscribeToAgent: mockSubscribeToAgent,
  unsubscribeFromAgent: vi.fn(),
  getAgentScrollback: mockGetAgentScrollback,
  onPtyEvent: mockOnPtyEvent,
}));

vi.mock('../ipc/git.js', () => ({
  getChangedFiles: vi.fn().mockResolvedValue([]),
  getAllFileDiffs: vi.fn().mockResolvedValue(''),
  getDiffBaseSha: vi.fn().mockResolvedValue('abc123sha'),
  mergeTask: vi.fn(),
}));

vi.mock('../ipc/tasks.js', () => ({
  createTask: mockCreateBackendTask,
  deleteTask: vi.fn().mockResolvedValue(undefined),
}));

vi.mock('../ipc/channels.js', () => ({
  IPC: {
    MCP_TaskCreated: 'mcp_task_created',
    MCP_TaskClosed: 'mcp_task_closed',
    MCP_TaskCleanupFailed: 'mcp_task_cleanup_failed',
    MCP_TaskStateSync: 'mcp_task_state_sync',
    MCP_CoordinatorNotificationStaged: 'mcp_coordinator_notification_staged',
    MCP_CoordinatorNotificationCleared: 'mcp_coordinator_notification_cleared',
    MCP_CoordinatorOrphanedNotification: 'mcp_coordinator_orphaned_notification',
    MCP_CoordinatorDeregistered: 'mcp_coordinator_deregistered',
    MCP_CoordinatorNotificationAck: 'mcp_coordinator_notification_ack',
  },
}));

// Import after mocks
const { Coordinator } = await import('./coordinator.js');
const { removePreambleBlock } = await import('./preamble.js');

// --- helpers ---
function getExitHandler(): (agentId: string, data: unknown) => void {
  const call = mockOnPtyEvent.mock.calls.find((c) => c[0] === 'exit');
  if (!call) throw new Error('exit handler not registered');
  return call[1] as (agentId: string, data: unknown) => void;
}

function getOutputCb(): (encoded: string) => void {
  const call = mockSubscribeToAgent.mock.calls[0];
  if (!call) throw new Error('subscribeToAgent not called');
  return call[1] as (encoded: string) => void;
}

function getAgentId(): string {
  const call = mockSubscribeToAgent.mock.calls[0];
  if (!call) throw new Error('subscribeToAgent not called');
  return call[0] as string;
}

function encode(s: string): string {
  return Buffer.from(s).toString('base64');
}

const mockWin = {
  isDestroyed: () => false,
  webContents: { send: mockNotifyRenderer },
} as unknown as import('electron').BrowserWindow;

// ─── registerCoordinator idempotency and restore path ────────────────────────

describe('Coordinator registerCoordinator — idempotency', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
  });

  it('registerCoordinator is idempotent — second call is a no-op', () => {
    coordinator.registerCoordinator('coord-1', 'proj-1', { worktreePath: '/tmp/project' });
    coordinator.registerCoordinator('coord-1', 'proj-1', { worktreePath: '/tmp/project' });
    // createTask should work — only one CoordinatorState entry
    expect(() =>
      coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' }),
    ).not.toThrow();
  });

  it('createTask succeeds when registerCoordinator is called before (not after) createTask', async () => {
    // Simulates the restore path: StartMCPServer calls registerCoordinator, then
    // the agent calls create_task over MCP. MCP_CoordinatorRegistered has NOT been
    // sent (App.tsx restore loop does not send it).
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await expect(
      coordinator.createTask({ name: 'restore-task', prompt: 'do', coordinatorTaskId: 'coord-1' }),
    ).resolves.toBeDefined();
    expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_task_created', expect.anything());
  });

  it('createTask notifies coordinator when coordinator registered only via registerCoordinator', async () => {
    // Simulates restore: StartMCPServer calls registerCoordinator internally.
    // No separate MCP_CoordinatorRegistered call occurs.
    coordinator.registerCoordinator('coord-1', 'proj-1');
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    // Should get a task created notification (not "coordinator not found" error)
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_task_created',
      expect.objectContaining({ name: 'test' }),
    );
  });
});

// ─── coordinator notification tests ───────────────────────────────────────────

describe('Coordinator coordinator notifications', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
  });

  it('does not notify when assignedPromptDelivered is false (startup idle)', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({
      name: 'test',
      prompt: 'do work',
      coordinatorTaskId: 'coord-1',
    });
    const outputCb = getOutputCb();
    outputCb(encode('Welcome ❯ '));
    expect(mockNotifyRenderer).not.toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.anything(),
    );
  });

  it('notifies coordinator when sub-task exits before prompt delivery (user closed early)', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do work', coordinatorTaskId: 'coord-1' });
    const agentId = getAgentId();
    const exitHandler = getExitHandler();
    // Never call markPromptDelivered — simulates user closing the task before prompt lands
    exitHandler(agentId, { exitCode: null });
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({ coordinatorTaskId: 'coord-1' }),
    );
  });

  it('notifies coordinator when sub-task idles after prompt delivery', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({
      name: 'test',
      prompt: 'do work',
      coordinatorTaskId: 'coord-1',
    });
    const outputCb = getOutputCb();

    coordinator.markPromptDelivered('task-1');

    outputCb(encode('Working... ❯ '));
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({
        coordinatorTaskId: 'coord-1',
        notificationIds: expect.any(Array),
      }),
    );
  });

  it('does not enqueue duplicate notification for repeated idles', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));
    outputCb(encode('Still here '));
    outputCb(encode('Idle again ❯ '));
    const calls = mockNotifyRenderer.mock.calls.filter(
      (c) => c[0] === 'mcp_coordinator_notification_staged',
    );
    const lastPayload = calls[calls.length - 1]?.[1] as { notificationIds: string[] };
    expect(lastPayload.notificationIds).toHaveLength(1);
  });

  it('upgrades idle→exited on PTY exit without adding duplicate', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    const agentId = getAgentId();
    const exitHandler = getExitHandler();
    outputCb(encode('Done ❯ '));
    mockNotifyRenderer.mockClear();
    exitHandler(agentId, { exitCode: 0 });
    const stagedCalls = mockNotifyRenderer.mock.calls.filter(
      (c) => c[0] === 'mcp_coordinator_notification_staged',
    );
    expect(stagedCalls).toHaveLength(1);
    const payload = stagedCalls[0][1] as { notificationIds: string[] };
    expect(payload.notificationIds).toHaveLength(1);
  });

  it('ack removes only the pending IDs in that batch', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'task-a', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));

    const stagedCallAck = mockNotifyRenderer.mock.calls.find(
      (c) => c[0] === 'mcp_coordinator_notification_staged',
    );
    if (!stagedCallAck) throw new Error('No staged call found');
    const { batchId } = stagedCallAck[1] as { batchId: string };

    coordinator.ackNotification('coord-1', batchId);
    const task = coordinator.getTask('task-1');
    expect(task?.reviewNotificationQueued).toBe(false);
  });

  it('ack is idempotent', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));
    const stagedCallIdempotent = mockNotifyRenderer.mock.calls.find(
      (c) => c[0] === 'mcp_coordinator_notification_staged',
    );
    if (!stagedCallIdempotent) throw new Error('No staged call found');
    const { batchId } = stagedCallIdempotent[1] as { batchId: string };
    expect(() => {
      coordinator.ackNotification('coord-1', batchId);
      coordinator.ackNotification('coord-1', batchId);
    }).not.toThrow();
  });

  it('uses shortened delay for non-zero exit', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const agentId = getAgentId();
    const exitHandler = getExitHandler();
    exitHandler(agentId, { exitCode: 1 });
    const stagedCallDelay = mockNotifyRenderer.mock.calls.find(
      (c) => c[0] === 'mcp_coordinator_notification_staged',
    );
    if (!stagedCallDelay) throw new Error('No staged call found');
    const { autoFireAt } = stagedCallDelay[1] as { autoFireAt: number };
    expect(autoFireAt - Date.now()).toBeLessThanOrEqual(15_500);
    expect(autoFireAt - Date.now()).toBeGreaterThan(9_000);
  });

  it('createTask rejects an unknown coordinator ID', async () => {
    await expect(
      coordinator.createTask({
        name: 'orphan',
        prompt: 'do',
        coordinatorTaskId: 'missing-coord',
      }),
    ).rejects.toThrow('Unknown coordinator: missing-coord');
  });

  it('clears staged notification when a notified task is closed', async () => {
    vi.useFakeTimers();
    try {
      coordinator.registerCoordinator('coord-1', 'proj-1');
      await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
      coordinator.markPromptDelivered('task-1');
      const outputCb = getOutputCb();
      outputCb(encode('Done ❯ '));

      expect(mockNotifyRenderer).toHaveBeenCalledWith(
        'mcp_coordinator_notification_staged',
        expect.objectContaining({ coordinatorTaskId: 'coord-1' }),
      );

      mockNotifyRenderer.mockClear();
      await coordinator.closeTask('task-1');

      expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_coordinator_notification_cleared', {
        coordinatorTaskId: 'coord-1',
      });

      mockNotifyRenderer.mockClear();
      vi.advanceTimersByTime(5 * 60_000);
      expect(mockNotifyRenderer).not.toHaveBeenCalledWith(
        'mcp_coordinator_notification_staged',
        expect.anything(),
      );
    } finally {
      vi.useRealTimers();
    }
  });
});

// ─── signal_done tests ────────────────────────────────────────────────────────

describe('Coordinator signal_done', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
  });

  it('stages notification with 5s delay without requiring markPromptDelivered', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.signalDone('task-1');

    const stagedCall = mockNotifyRenderer.mock.calls.find(
      (c) => c[0] === 'mcp_coordinator_notification_staged',
    );
    if (!stagedCall) throw new Error('No staged call found');
    const { autoFireAt } = stagedCall[1] as { autoFireAt: number };
    expect(autoFireAt - Date.now()).toBeLessThanOrEqual(5_500);
    expect(autoFireAt - Date.now()).toBeGreaterThan(4_000);
  });

  it('sends MCP_TaskStateSync to renderer', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.signalDone('task-1');

    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_task_state_sync',
      expect.objectContaining({
        taskId: 'task-1',
        signalDoneReceived: true,
      }),
    );
  });

  it('sets signalDoneAt on the task', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const before = new Date();
    coordinator.signalDone('task-1');
    const after = new Date();
    const task = coordinator.getTask('task-1');
    expect(task?.signalDoneAt).toBeDefined();
    expect(task?.signalDoneAt?.getTime()).toBeGreaterThanOrEqual(before.getTime());
    expect(task?.signalDoneAt?.getTime()).toBeLessThanOrEqual(after.getTime());
  });

  it('is a no-op for unknown taskId', () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    expect(() => coordinator.signalDone('nonexistent-task')).not.toThrow();
    expect(mockNotifyRenderer).not.toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.anything(),
    );
  });
});

// ─── spawn defaults / skipPermissions tests ───────────────────────────────────

describe('Coordinator sub-agent spawn settings', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('defaults to bare claude command', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(mockSpawnAgent).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({ command: 'claude' }),
    );
  });

  it('inherits coordinator command via setCoordinatorSpawnDefaults', async () => {
    coordinator.setCoordinatorSpawnDefaults('coord-1', '/usr/local/bin/claude', []);
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(mockSpawnAgent).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({ command: '/usr/local/bin/claude' }),
    );
  });

  it('inherits coordinator base args (e.g. --model)', async () => {
    coordinator.setCoordinatorSpawnDefaults('coord-1', 'claude', ['--model', 'claude-opus-4-7']);
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const spawnArgs = mockSpawnAgent.mock.calls[0][1].args as string[];
    expect(spawnArgs).toContain('--model');
    expect(spawnArgs).toContain('claude-opus-4-7');
  });

  it('adds --dangerously-skip-permissions when coordinator has propagateSkipPermissions', async () => {
    // skipPermissions is inherited from coordinator state, not from createTask opts.
    coordinator.registerCoordinator('coord-skip', 'proj-1', { skipPermissions: true });
    await coordinator.createTask({
      name: 'test',
      prompt: 'do',
      coordinatorTaskId: 'coord-skip',
    });
    const spawnArgs = mockSpawnAgent.mock.calls[0][1].args as string[];
    expect(spawnArgs).toContain('--dangerously-skip-permissions');
  });

  it('does not add --dangerously-skip-permissions when coordinator does not propagate', async () => {
    await coordinator.createTask({
      name: 'test',
      prompt: 'do',
      coordinatorTaskId: 'coord-1',
    });
    const spawnArgs = mockSpawnAgent.mock.calls[0][1].args as string[];
    expect(spawnArgs).not.toContain('--dangerously-skip-permissions');
  });

  it('inherited args do not include --dangerously-skip-permissions (handled separately)', async () => {
    // skip_permissions_args should not be passed as agentArgs — only agentDef.args (base args)
    coordinator.setCoordinatorSpawnDefaults('coord-1', 'claude', ['--model', 'claude-opus-4-7']);
    await coordinator.createTask({
      name: 'test',
      prompt: 'do',
      coordinatorTaskId: 'coord-1',
      skipPermissions: false,
    });
    const spawnArgs = mockSpawnAgent.mock.calls[0][1].args as string[];
    expect(spawnArgs).not.toContain('--dangerously-skip-permissions');
    expect(spawnArgs).toContain('--model');
  });

  it('spawns sub-agent in the sub-task worktree path', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(mockSpawnAgent).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({ cwd: '/tmp/test' }),
    );
  });

  it('uses docker run (dockerMode: true) when dockerContainerName is set — sub-task gets its own container', async () => {
    coordinator.setDockerContainerName('coord-1', 'my-container');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(mockSpawnAgent).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({
        // Sub-task uses docker run (dockerMode: true), not docker exec
        dockerMode: true,
        // Command is the agent command, not 'docker'
        command: 'claude',
        // Args are the agent args (not docker exec wrapper)
        args: expect.not.arrayContaining(['exec']),
      }),
    );
    // Coordinator container name is NOT in the args (sub-task has its own container)
    const spawnArgs = mockSpawnAgent.mock.calls[0][1].args as string[];
    expect(spawnArgs).not.toContain('my-container');
  });

  it('does not use docker mode when dockerContainerName is null', async () => {
    coordinator.setDockerContainerName('coord-1', null);
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(mockSpawnAgent).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({ command: 'claude' }),
    );
    const spawnCall = mockSpawnAgent.mock.calls[0][1] as { dockerMode?: boolean; args: string[] };
    expect(spawnCall.dockerMode).toBeUndefined();
    expect(spawnCall.args).not.toContain('docker');
  });

  it('docker run cwd is the sub-task worktree path, not the coordinator projectRoot', async () => {
    coordinator.setDockerContainerName('coord-1', 'my-container');
    // coordinator projectRoot is '/tmp/project', sub-task worktree is '/tmp/test'
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    // cwd (passed to pty.ts) is the sub-task worktree, not the coordinator's projectRoot
    const spawnCall = mockSpawnAgent.mock.calls[0][1] as { cwd: string };
    expect(spawnCall.cwd).toBe('/tmp/test');
    expect(spawnCall.cwd).not.toBe('/tmp/project');
  });
});

// ─── settings.local.json injection tests ─────────────────────────────────────

describe('Coordinator settings.local.json sub-task injection', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
  });

  it('writes settings.local.json with systemPrompt when file does not exist', async () => {
    mockFsAccess.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const settingsWrite = mockAtomicWriteFile.mock.calls.find((c) =>
      (c[0] as string).endsWith('settings.local.json'),
    );
    expect(settingsWrite).toBeDefined();
    const written = JSON.parse(settingsWrite?.[1] as string);
    expect(written.systemPrompt).toContain('signal_done');
    expect(written.systemPrompt).toContain('sub-task-mode');
  });

  it('appends preamble to existing systemPrompt in settings.local.json', async () => {
    mockFsAccess.mockResolvedValue(undefined);
    mockFsReadFile.mockResolvedValue(JSON.stringify({ systemPrompt: 'existing prompt' }));
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const settingsWrite = mockAtomicWriteFile.mock.calls.find((c) =>
      (c[0] as string).endsWith('settings.local.json'),
    );
    expect(settingsWrite).toBeDefined();
    const written = JSON.parse(settingsWrite?.[1] as string);
    expect(written.systemPrompt).toContain('existing prompt');
    expect(written.systemPrompt).toContain('signal_done');
  });

  it('preserves other keys in existing settings.local.json', async () => {
    mockFsAccess.mockResolvedValue(undefined);
    mockFsReadFile.mockResolvedValue(JSON.stringify({ permissions: { allow: ['Bash'] } }));
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const settingsWrite = mockAtomicWriteFile.mock.calls.find((c) =>
      (c[0] as string).endsWith('settings.local.json'),
    );
    expect(settingsWrite).toBeDefined();
    const written = JSON.parse(settingsWrite?.[1] as string);
    expect(written.permissions).toEqual({ allow: ['Bash'] });
    expect(written.systemPrompt).toContain('signal_done');
  });

  it('does not restore settings.local.json on idle (no restore needed)', async () => {
    mockFsAccess.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');

    const outputCb = getOutputCb();
    outputCb(encode('Working ❯ '));

    const settingsWriteCallsAfterIdle = mockAtomicWriteFile.mock.calls.filter((c) =>
      (c[0] as string).endsWith('settings.local.json'),
    );
    // Only the initial write; no re-write on idle
    expect(settingsWriteCallsAfterIdle).toHaveLength(1);
  });

  it('does not write to CLAUDE.md', async () => {
    mockFsAccess.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const claudeWrite = mockAtomicWriteFile.mock.calls.find((c) =>
      (c[0] as string).endsWith('CLAUDE.md'),
    );
    expect(claudeWrite).toBeUndefined();
  });
});

// ─── waitForIdle tests ────────────────────────────────────────────────────────

describe('Coordinator waitForIdle', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it('rejects for unknown taskId', async () => {
    await expect(coordinator.waitForIdle('nonexistent')).rejects.toThrow('Task not found');
  });

  it('resolves immediately when task is already idle', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));
    await expect(coordinator.waitForIdle('task-1')).resolves.toEqual({ reason: 'idle' });
  });

  it('resolves when agent outputs prompt', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const outputCb = getOutputCb();
    const waitPromise = coordinator.waitForIdle('task-1');
    outputCb(encode('working...'));
    outputCb(encode('Done ❯ '));
    await expect(waitPromise).resolves.toEqual({ reason: 'idle' });
  });

  it('resolves immediately when task is under human control', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.setTaskControl('task-1', 'human');
    await expect(coordinator.waitForIdle('task-1')).resolves.toEqual({ reason: 'human_control' });
  });

  it('rejects control changes for unknown tasks', () => {
    expect(() => coordinator.setTaskControl('missing-task', 'human')).toThrow(
      'Task not found: missing-task',
    );
  });

  it('rejects after timeout when task never idles', async () => {
    vi.useFakeTimers();
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const waitPromise = coordinator.waitForIdle('task-1', 1_000);
    vi.advanceTimersByTime(1_001);
    await expect(waitPromise).rejects.toThrow('Timed out');
  });

  it('resolves when task exits (PTY exit fires idle resolvers)', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const agentId = getAgentId();
    const exitHandler = getExitHandler();
    const waitPromise = coordinator.waitForIdle('task-1');
    exitHandler(agentId, { exitCode: 0 });
    await expect(waitPromise).resolves.toEqual({ reason: 'exited' });
  });

  it('fires pending idle resolvers when control returns to coordinator', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    // The real scenario: task is running, coordinator calls waitForIdle, user takes control, coordinator returns
    const waitPromise = coordinator.waitForIdle('task-1');
    coordinator.setTaskControl('task-1', 'coordinator');
    await expect(waitPromise).resolves.toEqual({ reason: 'idle' });
  });

  it('notifies coordinator when releasing control after waitForIdle was interrupted', async () => {
    await coordinator.createTask({ name: 'my-task', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const waitPromise = coordinator.waitForIdle('task-1');

    coordinator.setTaskControl('task-1', 'human');
    await expect(waitPromise).resolves.toEqual({ reason: 'human_control' });
    mockNotifyRenderer.mockClear();

    coordinator.setTaskControl('task-1', 'coordinator');

    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({
        coordinatorTaskId: 'coord-1',
        text: expect.stringContaining('"my-task" has been returned to coordinator control'),
      }),
    );
  });
});

// ─── waitForSignalDone tests ──────────────────────────────────────────────────

describe('Coordinator waitForSignalDone', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it('rejects for unknown coordinatorId', async () => {
    await expect(coordinator.waitForSignalDone('nonexistent-coord')).rejects.toThrow(
      'Coordinator not found',
    );
  });

  it('resolves immediately with unconsumed signal if already signalled', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.signalDone('task-1');
    await expect(coordinator.waitForSignalDone('coord-1')).resolves.toMatchObject({
      taskId: 'task-1',
      name: 'test',
      remaining: 0,
      status: expect.any(String),
      signalDoneAt: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/),
    });
  });

  it('resolves when signalDone is called, with remaining count', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const waitPromise = coordinator.waitForSignalDone('coord-1');
    coordinator.signalDone('task-1');
    await expect(waitPromise).resolves.toMatchObject({
      taskId: 'task-1',
      name: 'test',
      remaining: 0,
      status: expect.any(String),
      signalDoneAt: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/),
    });
  });

  it('resolves with timedOut:true when signal never arrives', async () => {
    vi.useFakeTimers();
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const waitPromise = coordinator.waitForSignalDone('coord-1', 1_000);
    vi.advanceTimersByTime(1_001);
    const result = await waitPromise;
    expect(result.timedOut).toBe(true);
    expect(result.remaining).toBeGreaterThanOrEqual(0);
  });

  it('returns remaining=1 when another task is still running', async () => {
    mockCreateBackendTask
      .mockResolvedValueOnce({ id: 'task-1', branch_name: 'task/a', worktree_path: '/tmp/a' })
      .mockResolvedValueOnce({ id: 'task-2', branch_name: 'task/b', worktree_path: '/tmp/b' });
    await coordinator.createTask({ name: 'task-a', prompt: 'do', coordinatorTaskId: 'coord-1' });
    await coordinator.createTask({ name: 'task-b', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const waitPromise = coordinator.waitForSignalDone('coord-1');
    coordinator.signalDone('task-1');
    await expect(waitPromise).resolves.toMatchObject({
      taskId: 'task-1',
      name: 'task-a',
      remaining: 1,
      status: expect.any(String),
      signalDoneAt: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/),
    });
  });

  it('does not stage pending notifications while any signal_done wait is active', async () => {
    mockCreateBackendTask
      .mockResolvedValueOnce({ id: 'task-1', branch_name: 'task/a', worktree_path: '/tmp/a' })
      .mockResolvedValueOnce({ id: 'task-2', branch_name: 'task/b', worktree_path: '/tmp/b' });

    await coordinator.createTask({ name: 'task-a', prompt: 'do', coordinatorTaskId: 'coord-1' });
    await coordinator.createTask({ name: 'task-b', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-2');
    mockNotifyRenderer.mockClear();

    const waitPromise = coordinator.waitForSignalDone('coord-1');
    const task2OutputCb = mockSubscribeToAgent.mock.calls[1][1] as (encoded: string) => void;
    task2OutputCb(encode('Done ❯ '));

    expect(mockNotifyRenderer).not.toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.anything(),
    );

    coordinator.signalDone('task-1');
    await expect(waitPromise).resolves.toMatchObject({ taskId: 'task-1' });
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({
        coordinatorTaskId: 'coord-1',
        text: expect.stringContaining('"task-b" ready for review'),
      }),
    );
  });

  it('clears an already staged notification when a signal_done wait starts', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));

    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({ coordinatorTaskId: 'coord-1' }),
    );

    mockNotifyRenderer.mockClear();
    const waitPromise = coordinator.waitForSignalDone('coord-1');

    expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_coordinator_notification_cleared', {
      coordinatorTaskId: 'coord-1',
    });

    coordinator.signalDone('task-1');
    await expect(waitPromise).resolves.toMatchObject({ taskId: 'task-1' });
    expect(mockNotifyRenderer).not.toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.anything(),
    );
  });
});

// ─── sendPrompt tests ─────────────────────────────────────────────────────────

describe('Coordinator sendPrompt', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('rejects for unknown taskId', async () => {
    await expect(coordinator.sendPrompt('nonexistent', 'hello')).rejects.toThrow('Task not found');
  });

  it('rejects when task is under human control', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.setTaskControl('task-1', 'human');
    await expect(coordinator.sendPrompt('task-1', 'hello')).rejects.toThrow('human control');
  });

  it('notifies coordinator when control returns after a blocked send_prompt', async () => {
    await coordinator.createTask({ name: 'my-task', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.setTaskControl('task-1', 'human');
    await expect(coordinator.sendPrompt('task-1', 'hello')).rejects.toThrow('human control');
    mockNotifyRenderer.mockClear();

    coordinator.setTaskControl('task-1', 'coordinator');

    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({
        coordinatorTaskId: 'coord-1',
        text: expect.stringContaining('"my-task" has been returned to coordinator control'),
      }),
    );
  });

  it('does not notify coordinator when control returns without a prior blocked send_prompt', async () => {
    await coordinator.createTask({ name: 'my-task', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.setTaskControl('task-1', 'human');
    mockNotifyRenderer.mockClear();

    coordinator.setTaskControl('task-1', 'coordinator');

    expect(mockNotifyRenderer).not.toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.anything(),
    );
  });

  it('syncs frontend done/review flags back to running when sending a new prompt', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    mockNotifyRenderer.mockClear();

    await coordinator.sendPrompt('task-1', 'new work');

    expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_task_state_sync', {
      taskId: 'task-1',
      signalDoneReceived: false,
      signalDoneAt: null,
      signalDoneConsumed: false,
      needsReview: false,
    });
  });
});

// ─── deregisterCoordinator tests ──────────────────────────────────────────────

describe('Coordinator deregisterCoordinator', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
  });

  it('is a no-op for unknown coordinator', () => {
    expect(() => coordinator.deregisterCoordinator('nonexistent')).not.toThrow();
  });

  it('child tasks are removed from internal map after coordinator is deregistered', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.deregisterCoordinator('coord-1');
    // markPromptDelivered is now a no-op — task was removed from this.tasks
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    mockNotifyRenderer.mockClear();
    outputCb(encode('Done ❯ '));
    // PTY output is silently dropped — no orphaned notification because the task entry is gone
    expect(mockNotifyRenderer).not.toHaveBeenCalledWith(
      'mcp_coordinator_orphaned_notification',
      expect.anything(),
    );
  });

  it('clears staged notification when coordinator is deregistered', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));

    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({ coordinatorTaskId: 'coord-1' }),
    );

    mockNotifyRenderer.mockClear();
    coordinator.deregisterCoordinator('coord-1');

    expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_coordinator_notification_cleared', {
      coordinatorTaskId: 'coord-1',
    });
  });

  it('hasActiveCoordinator returns false after deregister', () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    expect(coordinator.hasActiveCoordinator()).toBe(true);
    coordinator.deregisterCoordinator('coord-1');
    expect(coordinator.hasActiveCoordinator()).toBe(false);
  });

  it('deregister cleans up backend resource maps for child tasks', async () => {
    const { unsubscribeFromAgent } =
      await vi.importMock<typeof import('../ipc/pty.js')>('../ipc/pty.js');
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const agentId = getAgentId();

    // Confirm subscriber was registered
    expect(mockSubscribeToAgent).toHaveBeenCalledWith(agentId, expect.any(Function));

    coordinator.deregisterCoordinator('coord-1');

    // PTY subscriber must be unregistered
    expect(vi.mocked(unsubscribeFromAgent)).toHaveBeenCalledWith(agentId, expect.any(Function));

    // Internal maps must no longer hold stale entries
    const c = coordinator as unknown as {
      subscribers: Map<string, unknown>;
      tailBuffers: Map<string, unknown>;
      decoders: Map<string, unknown>;
      controlMap: Map<string, unknown>;
      blockedByHumanControl: Set<string>;
    };
    expect(c.subscribers.has(agentId)).toBe(false);
    expect(c.tailBuffers.has(agentId)).toBe(false);
    expect(c.decoders.has(agentId)).toBe(false);
  });
});

// ─── per-task projectRoot tests ───────────────────────────────────────────────

describe('Coordinator per-task projectRoot', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project-a');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('task stores the projectRoot at creation time', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(coordinator.getTask('task-1')?.projectRoot).toBe('/tmp/project-a');
  });

  it('later setDefaultProject does not affect existing task projectRoot', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.setDefaultProject('proj-2', '/tmp/project-b');
    expect(coordinator.getTask('task-1')?.projectRoot).toBe('/tmp/project-a');
  });
});

// ─── waiter resolver cleanup tests ───────────────────────────────────────────

describe('Coordinator waiter resolver cleanup on timeout', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.useFakeTimers();
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it('removes idle resolver after timeout so stale callback is not called on later idle', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const outputCb = getOutputCb();

    const p = coordinator.waitForIdle('task-1', 500);
    vi.advanceTimersByTime(501);
    await expect(p).rejects.toThrow('Timed out');

    // Now the task goes idle — no stale resolver should fire (no throw, no hang)
    let resolveCalled = false;
    const p2 = coordinator.waitForIdle('task-1', 500);
    p2.then(() => {
      resolveCalled = true;
    }).catch(() => {});
    outputCb(encode('Done ❯ '));
    await Promise.resolve(); // flush microtasks
    expect(resolveCalled).toBe(true);
  });

  it('removes signal_done resolver after timeout so stale callback is not called on later signal', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const p = coordinator.waitForSignalDone('coord-1', 500);
    vi.advanceTimersByTime(501);
    const timedOutResult = await p;
    expect(timedOutResult.timedOut).toBe(true);

    // signalDone fires after timeout — should resolve a new waiter, not the stale one
    let resolveCalled = false;
    const p2 = coordinator.waitForSignalDone('coord-1', 500);
    p2.then(() => {
      resolveCalled = true;
    }).catch(() => {});
    coordinator.signalDone('task-1');
    await Promise.resolve();
    expect(resolveCalled).toBe(true);
  });
});

// ─── MCP_TaskCreated spawn settings tests ────────────────────────────────────

describe('Coordinator MCP_TaskCreated spawn settings', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('includes agentCommand in MCP_TaskCreated payload', async () => {
    coordinator.setCoordinatorSpawnDefaults('coord-1', '/usr/local/bin/claude', []);
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_task_created',
      expect.objectContaining({ agentCommand: '/usr/local/bin/claude' }),
    );
  });

  it('includes agentArgs in MCP_TaskCreated payload (without --dangerously-skip-permissions)', async () => {
    coordinator.setCoordinatorSpawnDefaults('coord-1', 'claude', ['--model', 'claude-opus-4-7']);
    await coordinator.createTask({
      name: 'test',
      prompt: 'do',
      coordinatorTaskId: 'coord-1',
    });
    const payload = mockNotifyRenderer.mock.calls.find((c) => c[0] === 'mcp_task_created')?.[1] as {
      agentArgs: string[];
    };
    expect(payload.agentArgs).toContain('--model');
    expect(payload.agentArgs).toContain('claude-opus-4-7');
    expect(payload.agentArgs).not.toContain('--dangerously-skip-permissions');
  });

  it('includes skipPermissions true in MCP_TaskCreated payload when coordinator has propagateSkipPermissions', async () => {
    // skipPermissions is now inherited from the coordinator's propagateSkipPermissions,
    // not from createTask opts. Re-register with skipPermissions: true.
    coordinator.registerCoordinator('coord-skip', 'proj-1', { skipPermissions: true });
    await coordinator.createTask({
      name: 'test',
      prompt: 'do',
      coordinatorTaskId: 'coord-skip',
    });
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_task_created',
      expect.objectContaining({ skipPermissions: true }),
    );
  });

  it('includes skipPermissions false when not set', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_task_created',
      expect.objectContaining({ skipPermissions: false }),
    );
  });
});

// ─── Item 5: Sub-agent MCP config isolation ──────────────────────────────────

describe('Coordinator sub-task MCP config isolation', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('each sub-task gets its own unique task-id in .mcp.json args, not the coordinator id', async () => {
    mockCreateBackendTask
      .mockResolvedValueOnce({ id: 'task-a', branch_name: 'task/a', worktree_path: '/tmp/a' })
      .mockResolvedValueOnce({ id: 'task-b', branch_name: 'task/b', worktree_path: '/tmp/b' });

    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'task-a', prompt: 'do a', coordinatorTaskId: 'coord-1' });
    await coordinator.createTask({ name: 'task-b', prompt: 'do b', coordinatorTaskId: 'coord-1' });

    const configWrites = mockAtomicWriteFile.mock.calls.filter((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(configWrites).toHaveLength(2);

    const taskIds = configWrites.map((c) => {
      const cfg = JSON.parse(c[1] as string) as {
        mcpServers: { 'parallel-code': { args: string[] } };
      };
      const args = cfg.mcpServers['parallel-code'].args;
      const idx = args.indexOf('--task-id');
      return idx >= 0 ? args[idx + 1] : null;
    });

    // Each task must have its own id
    expect(taskIds[0]).toBe('task-a');
    expect(taskIds[1]).toBe('task-b');
    // Neither should use the coordinator id
    expect(taskIds).not.toContain('coord-1');
    // The two task ids must be distinct
    expect(taskIds[0]).not.toBe(taskIds[1]);
  });

  it('config files for two sub-tasks are written to different paths', async () => {
    mockCreateBackendTask
      .mockResolvedValueOnce({ id: 'task-a', branch_name: 'task/a', worktree_path: '/tmp/a' })
      .mockResolvedValueOnce({ id: 'task-b', branch_name: 'task/b', worktree_path: '/tmp/b' });

    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'task-a', prompt: 'do a', coordinatorTaskId: 'coord-1' });
    await coordinator.createTask({ name: 'task-b', prompt: 'do b', coordinatorTaskId: 'coord-1' });

    const configPaths = mockAtomicWriteFile.mock.calls
      .filter((c) => (c[0] as string).includes('parallel-code-subtask-'))
      .map((c) => c[0] as string);

    expect(configPaths[0]).not.toBe(configPaths[1]);
  });
});

// ─── MCP config restart rewrite tests ────────────────────────────────────────

describe('Coordinator MCP config restart rewrite', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('rewrites MCP config for existing task when server info changes (restart)', async () => {
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'old-token',
      'old-token',
      '/path/to/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const task = coordinator.getTask('task-1');
    expect(task?.mcpConfigPath).toBeDefined();

    const initialWrite = mockAtomicWriteFile.mock.calls.find((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(initialWrite).toBeDefined();
    if (!initialWrite) throw new Error('expected initial config write');
    const initialConfig = JSON.parse(initialWrite[1] as string) as {
      mcpServers: { 'parallel-code': { args: string[]; env: Record<string, string> } };
    };
    expect(initialConfig.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN']).toBe(
      'old-token',
    );
    expect(initialConfig.mcpServers['parallel-code'].args).toContain('http://localhost:3001');

    // Simulate coordinator restart with new port/token
    mockAtomicWriteFileSync.mockClear();
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3002',
      'new-token',
      'new-token',
      '/path/to/server.js',
    );

    const rewriteCall = mockAtomicWriteFileSync.mock.calls.find((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(rewriteCall).toBeDefined();
    if (!rewriteCall) throw new Error('expected rewrite call');
    // Path must be the same file the task already references
    expect(rewriteCall[0]).toBe(task?.mcpConfigPath);

    // Rewritten config is valid JSON with updated URL and token, preserving the task id
    const newConfig = JSON.parse(rewriteCall[1] as string) as {
      mcpServers: { 'parallel-code': { args: string[]; env: Record<string, string> } };
    };
    const newArgs = newConfig.mcpServers['parallel-code'].args;
    expect(newConfig.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN']).toBe('new-token');
    expect(newArgs).toContain('http://localhost:3002');
    expect(newArgs).toContain('task-1');
    // Old values must be gone
    expect(newConfig.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN']).not.toBe(
      'old-token',
    );
    expect(newArgs).not.toContain('http://localhost:3001');
  });

  it('does not write config files when no tasks exist on setMCPServerInfo', () => {
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'old-token',
      'old-token',
      '/path/to/server.js',
    );
    mockAtomicWriteFileSync.mockClear();
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3002',
      'new-token',
      'new-token',
      '/path/to/server.js',
    );

    const configWrites = mockAtomicWriteFileSync.mock.calls.filter((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(configWrites).toHaveLength(0);
  });

  it('rewrites configs for all existing tasks on restart', async () => {
    mockCreateBackendTask
      .mockResolvedValueOnce({ id: 'task-1', branch_name: 'task/a', worktree_path: '/tmp/a' })
      .mockResolvedValueOnce({ id: 'task-2', branch_name: 'task/b', worktree_path: '/tmp/b' });

    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'old-token',
      'old-token',
      '/path/to/server.js',
    );
    await coordinator.createTask({ name: 'task-a', prompt: 'do', coordinatorTaskId: 'coord-1' });
    await coordinator.createTask({ name: 'task-b', prompt: 'do', coordinatorTaskId: 'coord-1' });

    mockAtomicWriteFileSync.mockClear();
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3002',
      'new-token',
      'new-token',
      '/path/to/server.js',
    );

    const rewrites = mockAtomicWriteFileSync.mock.calls.filter((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(rewrites).toHaveLength(2);

    for (const rewrite of rewrites) {
      const cfg = JSON.parse(rewrite[1] as string) as {
        mcpServers: { 'parallel-code': { args: string[]; env: Record<string, string> } };
      };
      expect(cfg.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN']).toBe('new-token');
      expect(cfg.mcpServers['parallel-code'].args).toContain('http://localhost:3002');
    }
  });

  it('does not rewrite config for tasks that have no mcpConfigPath (spawned without MCP info)', async () => {
    // No setMCPServerInfo before createTask — task gets no mcpConfigPath
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(coordinator.getTask('task-1')?.mcpConfigPath).toBeUndefined();

    mockAtomicWriteFileSync.mockClear();
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3002',
      'new-token',
      'new-token',
      '/path/to/server.js',
    );

    const configWrites = mockAtomicWriteFileSync.mock.calls.filter((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(configWrites).toHaveLength(0);
  });
});

// ─── Two-class token: subtask configs use subtaskToken, not coordinator token ──

describe('Coordinator two-class token — subtask configs use subtaskToken', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('createTask writes subtaskToken (not coordinator token) into the sub-task MCP config', async () => {
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'coordinator-secret',
      'subtask-secret',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const configWrite = mockAtomicWriteFile.mock.calls.find((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(configWrite).toBeDefined();
    if (!configWrite) throw new Error('expected config write');

    const config = JSON.parse(configWrite[1] as string) as {
      mcpServers: { 'parallel-code': { env: Record<string, string> } };
    };
    const writtenToken = config.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN'];
    expect(writtenToken).toBe('subtask-secret');
    expect(writtenToken).not.toBe('coordinator-secret');
  });

  it('setMCPServerInfo rewrites existing sub-task configs with subtaskToken on restart', async () => {
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'old-coordinator',
      'old-subtask',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    mockAtomicWriteFileSync.mockClear();

    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3002',
      'new-coordinator',
      'new-subtask',
      '/path/server.js',
    );

    const rewrite = mockAtomicWriteFileSync.mock.calls.find((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(rewrite).toBeDefined();
    if (!rewrite) throw new Error('expected rewrite');

    const config = JSON.parse(rewrite[1] as string) as {
      mcpServers: { 'parallel-code': { env: Record<string, string> } };
    };
    const writtenToken = config.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN'];
    expect(writtenToken).toBe('new-subtask');
    expect(writtenToken).not.toBe('new-coordinator');
  });
});

// ─── Item 5: Coordinator restart hydration ────────────────────────────────────

describe('Coordinator hydrateTask — restart hydration', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('hydrateTask + getTask returns all expected fields', () => {
    coordinator.hydrateTask({
      id: 'hydrated-1',
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/hydrated',
      agentId: 'agent-hydrated',
      coordinatorTaskId: 'coord-1',
    });

    const task = coordinator.getTask('hydrated-1');
    expect(task).toBeDefined();
    expect(task?.id).toBe('hydrated-1');
    expect(task?.name).toBe('hydrated-task');
    expect(task?.projectId).toBe('proj-1');
    expect(task?.branchName).toBe('task/hydrated');
    expect(task?.worktreePath).toBe('/tmp/hydrated');
    expect(task?.agentId).toBe('agent-hydrated');
    expect(task?.coordinatorTaskId).toBe('coord-1');
    expect(task?.status).toBe('exited');
  });

  it('hydrateTask + waitForIdle resolves immediately for exited status', async () => {
    coordinator.hydrateTask({
      id: 'hydrated-1',
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/hydrated',
      agentId: 'agent-hydrated',
      coordinatorTaskId: 'coord-1',
    });

    await expect(coordinator.waitForIdle('hydrated-1')).resolves.toEqual({ reason: 'exited' });
  });

  it('hydrateTask + waitForSignalDone resolves if signalDoneAt was already set', async () => {
    coordinator.hydrateTask({
      id: 'hydrated-1',
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/hydrated',
      agentId: 'agent-hydrated',
      coordinatorTaskId: 'coord-1',
    });

    const task = coordinator.getTask('hydrated-1');
    expect(task).toBeDefined();
    if (!task) throw new Error('task not found');
    task.signalDoneAt = new Date();
    task.signalDoneConsumed = false;

    await expect(coordinator.waitForSignalDone('coord-1', 100)).resolves.toMatchObject({
      taskId: 'hydrated-1',
      remaining: expect.any(Number),
    });
  });

  it('hydrateTask + sendPrompt works without error', async () => {
    coordinator.hydrateTask({
      id: 'hydrated-1',
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/hydrated',
      agentId: 'agent-hydrated',
      coordinatorTaskId: 'coord-1',
    });

    await expect(coordinator.sendPrompt('hydrated-1', 'hello')).resolves.toBeUndefined();
  });

  it('hydrateTask controlledBy:human blocks sendPrompt', async () => {
    coordinator.hydrateTask({
      id: 'hydrated-1',
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/hydrated',
      agentId: 'agent-hydrated',
      coordinatorTaskId: 'coord-1',
      controlledBy: 'human',
    });

    await expect(coordinator.sendPrompt('hydrated-1', 'hello')).rejects.toThrow('human control');
  });
});

// ─── Item 6: Control state restart replay ─────────────────────────────────────

describe('Coordinator setTaskControl — blocked send until release', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('sendPrompt is blocked when task is human-controlled', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.setTaskControl('task-1', 'human');
    await expect(coordinator.sendPrompt('task-1', 'hello')).rejects.toThrow('human control');
  });

  it('sendPrompt is unblocked after setTaskControl coordinator', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.setTaskControl('task-1', 'human');
    coordinator.setTaskControl('task-1', 'coordinator');
    await expect(coordinator.sendPrompt('task-1', 'hello')).resolves.toBeUndefined();
  });

  it('waitForIdle resolves immediately with human_control reason when human has control', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.setTaskControl('task-1', 'human');
    await expect(coordinator.waitForIdle('task-1')).resolves.toEqual({ reason: 'human_control' });
  });

  it('when sendPrompt was blocked, releasing control stages a notification', async () => {
    await coordinator.createTask({ name: 'my-task', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    coordinator.setTaskControl('task-1', 'human');

    // sendPrompt throws — this marks the task as blocked
    await expect(coordinator.sendPrompt('task-1', 'hello')).rejects.toThrow('human control');

    mockNotifyRenderer.mockClear();
    coordinator.setTaskControl('task-1', 'coordinator');

    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({
        coordinatorTaskId: 'coord-1',
        text: expect.stringContaining('returned to coordinator'),
      }),
    );
  });
});

// ─── Item 7: Notification lifecycle under waitForSignalDone ───────────────────

describe('Coordinator waitForSignalDone — notification lifecycle', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it('staged notification is cleared when waitForSignalDone starts', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));

    // Confirm a notification was staged
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.objectContaining({ coordinatorTaskId: 'coord-1' }),
    );

    mockNotifyRenderer.mockClear();

    // Starting a wait should clear the staged notification
    const waitPromise = coordinator.waitForSignalDone('coord-1', 100);
    expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_coordinator_notification_cleared', {
      coordinatorTaskId: 'coord-1',
    });

    // Clean up — reject or resolve the promise
    coordinator.signalDone('task-1');
    await waitPromise.catch(() => {});
  });

  it('task exit while wait active does not re-stage notification', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');

    const agentId = getAgentId();
    const exitHandler = getExitHandler();

    const waitPromise = coordinator.waitForSignalDone('coord-1', 5_000);
    mockNotifyRenderer.mockClear();

    exitHandler(agentId, { exitCode: 0 });

    // While an active signal_done wait is in progress, staging should be suppressed
    const stagedCalls = mockNotifyRenderer.mock.calls.filter(
      (c) => c[0] === 'mcp_coordinator_notification_staged',
    );
    expect(stagedCalls).toHaveLength(0);

    // Clean up
    coordinator.signalDone('task-1');
    await waitPromise.catch(() => {});
  });

  it('wait timeout causes pending notifications to be staged after wait ends', async () => {
    vi.useFakeTimers();
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');

    // Trigger an idle so a notification is queued
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));

    // Start wait — this clears staged notifications
    const waitPromise = coordinator.waitForSignalDone('coord-1', 100);
    mockNotifyRenderer.mockClear();

    // Time out the wait
    vi.advanceTimersByTime(200);
    const timedOutResult = await waitPromise;
    expect(timedOutResult.timedOut).toBe(true);

    // After timeout, pending notifications should be re-staged
    const stagedCalls = mockNotifyRenderer.mock.calls.filter(
      (c) => c[0] === 'mcp_coordinator_notification_staged',
    );
    expect(stagedCalls).toHaveLength(1);
  });

  it('coordinator deregistered — pending task notification fires orphaned event on next idle', async () => {
    await coordinator.createTask({
      name: 'orphan-test',
      prompt: 'do',
      coordinatorTaskId: 'coord-1',
    });
    coordinator.markPromptDelivered('task-1');
    mockNotifyRenderer.mockClear();

    // Deregister the coordinator (no active wait — simpler scenario)
    coordinator.deregisterCoordinator('coord-1');

    // After deregister, idle output should fire an orphaned notification (coordinator is gone)
    const outputCb = getOutputCb();
    outputCb(encode('Done ❯ '));

    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_orphaned_notification',
      expect.objectContaining({ subTaskId: 'task-1' }),
    );
  });
});

// ─── Item 8: Sub-task lifecycle cleanup failure tests ─────────────────────────

describe('Coordinator cleanupTask — failure resilience', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('deleteTask failure retains task in map and emits MCP_TaskCleanupFailed, not MCP_TaskClosed', async () => {
    const { deleteTask: mockDeleteTask } =
      await vi.importMock<typeof import('../ipc/tasks.js')>('../ipc/tasks.js');
    vi.mocked(mockDeleteTask).mockRejectedValueOnce(new Error('delete failed'));

    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    await coordinator.closeTask('task-1');

    // Task must remain in backend map so retry is possible
    expect(coordinator.getTask('task-1')).toBeDefined();
    // MCP_TaskClosed must NOT be sent
    expect(mockNotifyRenderer).not.toHaveBeenCalledWith('mcp_task_closed', expect.anything());
    // Failure event must be sent with the error message
    expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_task_cleanup_failed', {
      taskId: 'task-1',
      error: 'delete failed',
    });
  });

  it('deleteTask failure preserves controlMap and blockedByHumanControl state', async () => {
    const { deleteTask: mockDeleteTask } =
      await vi.importMock<typeof import('../ipc/tasks.js')>('../ipc/tasks.js');
    vi.mocked(mockDeleteTask).mockRejectedValueOnce(new Error('delete failed'));

    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    // Simulate the task being under coordinator control
    coordinator.setTaskControl('task-1', 'coordinator');
    await coordinator.closeTask('task-1');

    // Backend task still findable — retry via closeTask should work
    expect(coordinator.getTask('task-1')).toBeDefined();
  });

  it('MCP config file deletion failure is swallowed and task is removed', async () => {
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    mockUnlinkSync.mockImplementationOnce(() => {
      throw new Error('unlink failed');
    });

    await expect(coordinator.closeTask('task-1')).resolves.toBeUndefined();
    expect(coordinator.getTask('task-1')).toBeUndefined();
  });

  it('subscriber is unregistered on cleanup', async () => {
    const { unsubscribeFromAgent } =
      await vi.importMock<typeof import('../ipc/pty.js')>('../ipc/pty.js');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(mockSubscribeToAgent).toHaveBeenCalled();

    await coordinator.closeTask('task-1');

    expect(vi.mocked(unsubscribeFromAgent)).toHaveBeenCalled();
  });
});

// ─── Docker cleanup sequencing ────────────────────────────────────────────────

describe('Coordinator cleanupTask — Docker sub-task container stop', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
    coordinator.setDockerContainerName('coord-1', 'my-coord-container');
    coordinator.setDockerImage('coord-1', 'parallel-code-agent:latest');
  });

  it('closeTask calls killAgent (which stops the sub-task Docker container via pty.ts)', async () => {
    const { killAgent } = await vi.importMock<typeof import('../ipc/pty.js')>('../ipc/pty.js');

    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    await coordinator.closeTask('task-1');

    // killAgent is responsible for stopping the Docker container (via stopDockerContainer in pty.ts)
    expect(vi.mocked(killAgent)).toHaveBeenCalled();
  });

  it('closeTask does not call docker exec kill — sub-task has its own container', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    vi.clearAllMocks(); // reset after createTask
    await coordinator.closeTask('task-1');

    // execFile is used for git commands only — never for 'docker exec kill'
    const dockerExecKillCall = mockExecFile.mock.calls.find(
      (c) =>
        c[0] === 'docker' &&
        Array.isArray(c[1]) &&
        c[1][0] === 'exec' &&
        c[1].includes('my-coord-container'),
    );
    expect(dockerExecKillCall).toBeUndefined();
  });

  it('deleteTask is called immediately after killAgent (no waiting for docker exec)', async () => {
    const { deleteTask: mockDeleteTask } =
      await vi.importMock<typeof import('../ipc/tasks.js')>('../ipc/tasks.js');
    vi.mocked(mockDeleteTask).mockResolvedValue(undefined);

    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    await coordinator.closeTask('task-1');

    // deleteTask is called (task is cleaned up)
    expect(vi.mocked(mockDeleteTask)).toHaveBeenCalled();
    expect(coordinator.getTask('task-1')).toBeUndefined();
    expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_task_closed', { taskId: 'task-1' });
  });
});

// ─── Token rotation tests ──────────────────────────────────────────────────────

describe('Coordinator setMCPServerInfo — token rotation', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('rewrites existing task config files when token rotates', async () => {
    // Set up initial MCP server info
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://127.0.0.1:3001',
      'old-token',
      'old-token',
      '/path/to/mcp-server.cjs',
    );

    // Create a task — this writes a config file (mcpConfigPath set if server info is present)
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    // Clear write calls from task creation
    mockAtomicWriteFileSync.mockClear();

    // Rotate to a new token
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://127.0.0.1:3002',
      'new-token-xyz',
      'new-token-xyz',
      '/path/to/mcp-server.cjs',
    );

    // At least one writeFileSync call should have the new token
    const rewriteCalls = mockAtomicWriteFileSync.mock.calls;
    const hasNewToken = rewriteCalls.some((c) => {
      const content = typeof c[1] === 'string' ? c[1] : '';
      return content.includes('new-token-xyz');
    });

    // If task had an mcpConfigPath, it should be rewritten.
    // (If task had no mcpConfigPath — e.g. Docker mode — rewrite is skipped, which is also correct.)
    const task = coordinator.getTask('task-1');
    if (task?.mcpConfigPath) {
      expect(hasNewToken).toBe(true);
    } else {
      // Docker mode: no host config file to rewrite (sub-tasks use in-container config)
      expect(true).toBe(true);
    }
  });

  it('setMCPServerInfo with no existing tasks writes nothing', () => {
    mockAtomicWriteFileSync.mockClear();
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://127.0.0.1:3001',
      'new-token',
      'new-token',
      '/path/mcp.cjs',
    );
    // No tasks yet — nothing to rewrite
    const rewriteCalls = mockAtomicWriteFileSync.mock.calls.filter(
      (c) => typeof c[1] === 'string' && c[1].includes('new-token'),
    );
    expect(rewriteCalls).toHaveLength(0);
  });
});

// ─── Multiple coordinators in Docker ─────────────────────────────────────────

describe('Multiple Docker coordinators — isolation', () => {
  let coordA: InstanceType<typeof Coordinator>;
  let coordB: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });

    coordA = new Coordinator();
    coordA.setWindow(mockWin);
    coordA.setDefaultProject('proj-a', '/tmp/project-a');
    coordA.registerCoordinator('coord-a', 'proj-a');

    coordB = new Coordinator();
    coordB.setWindow(mockWin);
    coordB.setDefaultProject('proj-b', '/tmp/project-b');
    coordB.registerCoordinator('coord-b', 'proj-b');
  });

  it('each coordinator has an isolated docker container name (no singleton leak)', () => {
    coordA.setDockerContainerName('coord-a', 'parallel-code-container-a');
    coordB.setDockerContainerName('coord-b', 'parallel-code-container-b');

    // The container names must differ — no shared singleton
    expect('parallel-code-container-a').not.toBe('parallel-code-container-b');
  });

  it('sub-task MCP config for coord-a uses coord-a coordinator id, not coord-b', async () => {
    coordA.setMCPServerInfo(
      'coord-a',
      'http://localhost:3001',
      'tok-a',
      'subtask-tok-a',
      '/path/server.js',
    );
    await coordA.createTask({ name: 'task-a', prompt: 'do a', coordinatorTaskId: 'coord-a' });

    const configWrites = mockAtomicWriteFile.mock.calls.filter((c) =>
      (c[0] as string).includes('parallel-code-subtask-'),
    );
    expect(configWrites).toHaveLength(1);

    const cfg = JSON.parse(configWrites[0][1] as string) as {
      mcpServers: { 'parallel-code': { args: string[]; env: Record<string, string> } };
    };
    expect(cfg.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN']).toBe('subtask-tok-a');
    expect(cfg.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN']).not.toBe(
      'subtask-tok-b',
    );
  });
});

// ─── Sub-task per-container spawn (#31) ──────────────────────────────────────

describe('Coordinator Docker sub-task — per-container spawn', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
    coordinator.setDockerContainerName('coord-1', 'my-coord-container');
    coordinator.setDockerImage('coord-1', 'parallel-code-agent:latest');
  });

  it('sub-task spawned with dockerMode: true (docker run), not docker exec', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const spawnCall = mockSpawnAgent.mock.calls[0][1] as {
      command: string;
      args: string[];
      dockerMode?: boolean;
    };
    // Must use dockerMode: true so pty.ts builds `docker run`
    expect(spawnCall.dockerMode).toBe(true);
    // Command is the agent, not 'docker'
    expect(spawnCall.command).toBe('claude');
    // Args never contain 'exec'
    expect(spawnCall.args).not.toContain('exec');
  });

  it('sub-task does NOT reference the coordinator container name in spawn args', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const spawnCall = mockSpawnAgent.mock.calls[0][1] as { args: string[] };
    // Each sub-task gets its own container — coordinator container name is never used as spawn target
    expect(spawnCall.args).not.toContain('my-coord-container');
  });
});

// ─── Interrupted bootstrap / exit before prompt delivery ─────────────────────

describe('Coordinator interrupted bootstrap', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('exits before prompt delivery notifies coordinator so it does not hang forever', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const agentId = getAgentId();
    const exitHandler = getExitHandler();

    // Kill the container before any output was produced — simulates trust-prompt hang / OOM kill
    exitHandler(agentId, { exitCode: 137 }); // 137 = SIGKILL

    // Coordinator must have been notified (not left waiting for prompt)
    expect(mockNotifyRenderer).toHaveBeenCalledWith(
      'mcp_coordinator_notification_staged',
      expect.anything(),
    );
  });

  it('task status is exited after unexpected container death', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const agentId = getAgentId();
    const exitHandler = getExitHandler();
    exitHandler(agentId, { exitCode: 1 });

    const task = coordinator.getTask('task-1');
    expect(task?.status).toBe('exited');
  });
});

// ─── Very fast prompt before subscription (scrollback detection) ─────────────

describe('Coordinator very fast prompt — scrollback detection', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('detects idle state via scrollback when prompt arrives before subscription', async () => {
    // Simulate container that printed ❯ before we subscribed: getAgentScrollback returns it.
    mockGetAgentScrollback.mockReturnValueOnce(
      Buffer.from('Welcome to Claude Code ❯ ').toString('base64'),
    );

    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const task = coordinator.getTask('task-1');
    // Task must be idle (not still "running") because scrollback contained ❯
    expect(task?.status).toBe('idle');
  });

  it('task remains running when scrollback contains no prompt', async () => {
    // No ❯ in scrollback — agent is still initializing
    mockGetAgentScrollback.mockReturnValueOnce(
      Buffer.from('Loading… please wait').toString('base64'),
    );

    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const task = coordinator.getTask('task-1');
    expect(task?.status).toBe('running');
  });

  it('null scrollback (agent not yet started) leaves task in running state', async () => {
    mockGetAgentScrollback.mockReturnValueOnce(null);

    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const task = coordinator.getTask('task-1');
    expect(task?.status).toBe('running');
  });
});

// ─── Coordinator close with active sub-tasks ─────────────────────────────────

describe('Coordinator close with active sub-tasks', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('killAgent is called for each active sub-task when coordinator closes', async () => {
    mockCreateBackendTask
      .mockResolvedValueOnce({ id: 'task-a', branch_name: 'task/a', worktree_path: '/tmp/a' })
      .mockResolvedValueOnce({ id: 'task-b', branch_name: 'task/b', worktree_path: '/tmp/b' });

    await coordinator.createTask({ name: 'task-a', prompt: 'do a', coordinatorTaskId: 'coord-1' });
    await coordinator.createTask({ name: 'task-b', prompt: 'do b', coordinatorTaskId: 'coord-1' });

    const { killAgent: mockKillFn } =
      await vi.importMock<typeof import('../ipc/pty.js')>('../ipc/pty.js');
    vi.mocked(mockKillFn).mockClear();

    await coordinator.closeTask('task-a');
    await coordinator.closeTask('task-b');

    expect(vi.mocked(mockKillFn)).toHaveBeenCalledTimes(2);
  });

  it('MCP config temp file is deleted on closeTask (TODOS.md item 10)', async () => {
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const task = coordinator.getTask('task-1');
    const configPath = task?.mcpConfigPath;
    expect(configPath).toBeDefined();
    expect(configPath).toMatch(/parallel-code-subtask-task-1\.json$/);

    mockUnlinkSync.mockClear();
    await coordinator.closeTask('task-1');

    // unlinkSync must be called with the config path
    const unlinkCall = mockUnlinkSync.mock.calls.find((c) => c[0] === configPath);
    expect(unlinkCall).toBeDefined();
  });

  it('does not call unlinkSync for tasks created without MCP server info', async () => {
    // No setMCPServerInfo call — task gets no mcpConfigPath
    await coordinator.createTask({ name: 'test', prompt: 'do work', coordinatorTaskId: 'coord-1' });

    expect(coordinator.getTask('task-1')?.mcpConfigPath).toBeUndefined();

    mockUnlinkSync.mockClear();
    await coordinator.closeTask('task-1');

    // unlinkSync should NOT have been called with a parallel-code path
    const parallelCodeCalls = mockUnlinkSync.mock.calls.filter(
      (c) => typeof c[0] === 'string' && (c[0] as string).includes('parallel-code-subtask'),
    );
    expect(parallelCodeCalls).toHaveLength(0);
  });

  it('task is removed from map even when docker exec sub-tasks are active', async () => {
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator.setDockerContainerName('coord-1', 'my-container');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    expect(coordinator.getTask('task-1')).toBeDefined();
    await coordinator.closeTask('task-1');
    expect(coordinator.getTask('task-1')).toBeUndefined();
  });
});

// ─── App crash/restart with running Docker container ─────────────────────────

describe('Coordinator restart hydration with Docker container name', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('hydrateTask with controlledBy=human restores human control', () => {
    coordinator.hydrateTask({
      id: 'task-1',
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/test',
      agentId: 'agent-hydrated',
      coordinatorTaskId: 'coord-1',
      controlledBy: 'human',
    });

    // setTaskControl should restore human control
    coordinator.setTaskControl('task-1', 'human');
    // Task must be under human control — verify via getTask
    const task = coordinator.getTask('task-1');
    expect(task).toBeDefined();
  });

  it('hydrateTask restores task so closeTask can clean it up after restart', async () => {
    coordinator.hydrateTask({
      id: 'task-1',
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/test',
      agentId: 'agent-hydrated',
      coordinatorTaskId: 'coord-1',
    });

    expect(coordinator.getTask('task-1')).toBeDefined();
    await coordinator.closeTask('task-1');
    expect(coordinator.getTask('task-1')).toBeUndefined();
  });
});

// ─── removeCoordinatedTask tests ─────────────────────────────────────────────

describe('Coordinator removeCoordinatedTask', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('is a no-op for unknown taskId', () => {
    expect(() => coordinator.removeCoordinatedTask('nonexistent')).not.toThrow();
  });

  it('removes task from internal map', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(coordinator.getTask('task-1')).toBeDefined();

    coordinator.removeCoordinatedTask('task-1');

    expect(coordinator.getTask('task-1')).toBeUndefined();
  });

  it('unsubscribes the PTY output callback', async () => {
    const { unsubscribeFromAgent } =
      await vi.importMock<typeof import('../ipc/pty.js')>('../ipc/pty.js');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const agentId = getAgentId();

    coordinator.removeCoordinatedTask('task-1');

    expect(vi.mocked(unsubscribeFromAgent)).toHaveBeenCalledWith(agentId, expect.any(Function));
  });

  it('cleans up internal resource maps (subscribers, tailBuffers, decoders, controlMap, human control markers)', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const agentId = getAgentId();
    coordinator.setTaskControl('task-1', 'human');
    await coordinator.waitForIdle('task-1');
    await coordinator.sendPrompt('task-1', 'hello').catch(() => {});

    coordinator.removeCoordinatedTask('task-1');

    const c = coordinator as unknown as {
      subscribers: Map<string, unknown>;
      tailBuffers: Map<string, unknown>;
      decoders: Map<string, unknown>;
      controlMap: Map<string, unknown>;
      blockedByHumanControl: Set<string>;
      interruptedByHumanControl: Set<string>;
    };
    expect(c.subscribers.has(agentId)).toBe(false);
    expect(c.tailBuffers.has(agentId)).toBe(false);
    expect(c.decoders.has(agentId)).toBe(false);
    expect(c.controlMap.has('task-1')).toBe(false);
    expect(c.blockedByHumanControl.has('task-1')).toBe(false);
    expect(c.interruptedByHumanControl.has('task-1')).toBe(false);
  });

  it('deregister detaches child task state and preserves review only after prompt delivery', async () => {
    coordinator.registerCoordinator('coord-1', 'proj-1');
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    coordinator.markPromptDelivered('task-1');
    mockNotifyRenderer.mockClear();

    coordinator.deregisterCoordinator('coord-1');

    expect(mockNotifyRenderer).toHaveBeenCalledWith('mcp_task_state_sync', {
      taskId: 'task-1',
      coordinatedBy: null,
      controlledBy: null,
      mcpConfigPath: null,
      mcpStartupStatus: null,
      mcpStartupError: null,
      needsReview: true,
    });
  });

  it('resolves pending idle waiters with removed reason', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const waitPromise = coordinator.waitForIdle('task-1');

    coordinator.removeCoordinatedTask('task-1');

    await expect(waitPromise).resolves.toEqual({ reason: 'removed' });
  });

  it('deletes MCP config file when mcpConfigPath is set', async () => {
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const configPath = coordinator.getTask('task-1')?.mcpConfigPath;
    expect(configPath).toBeDefined();

    mockUnlinkSync.mockClear();
    coordinator.removeCoordinatedTask('task-1');

    const unlinkCall = mockUnlinkSync.mock.calls.find((c) => c[0] === configPath);
    expect(unlinkCall).toBeDefined();
  });

  it('does not call unlinkSync for tasks with no mcpConfigPath', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    expect(coordinator.getTask('task-1')?.mcpConfigPath).toBeUndefined();

    mockUnlinkSync.mockClear();
    coordinator.removeCoordinatedTask('task-1');

    const parallelCodeCalls = mockUnlinkSync.mock.calls.filter(
      (c) => typeof c[0] === 'string' && (c[0] as string).includes('parallel-code-subtask'),
    );
    expect(parallelCodeCalls).toHaveLength(0);
  });

  it('does NOT notify renderer (UI already removed the task)', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    mockNotifyRenderer.mockClear();

    coordinator.removeCoordinatedTask('task-1');

    expect(mockNotifyRenderer).not.toHaveBeenCalledWith('mcp_task_closed', expect.anything());
  });

  it('does NOT kill the agent (UI already did that)', async () => {
    const { killAgent: mockKillFn } =
      await vi.importMock<typeof import('../ipc/pty.js')>('../ipc/pty.js');
    vi.mocked(mockKillFn).mockClear();
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    vi.mocked(mockKillFn).mockClear();

    coordinator.removeCoordinatedTask('task-1');

    expect(vi.mocked(mockKillFn)).not.toHaveBeenCalled();
  });

  it('does NOT delete the worktree (UI already did that)', async () => {
    const { deleteTask: mockDeleteTask } =
      await vi.importMock<typeof import('../ipc/tasks.js')>('../ipc/tasks.js');
    vi.mocked(mockDeleteTask).mockClear();
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    vi.mocked(mockDeleteTask).mockClear();

    coordinator.removeCoordinatedTask('task-1');

    expect(vi.mocked(mockDeleteTask)).not.toHaveBeenCalled();
  });
});

// ─── #33: Post-restart coordinator flow integration test ─────────────────────

describe('Coordinator restart round-trip integration', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('hydrateTask rewrites config with new subtaskToken (not coordinator token) when server info is already set', () => {
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3002',
      'new-coordinator-secret',
      'new-subtask-secret',
      '/path/server.js',
    );

    const taskId = 'hydrated-restart-1';
    const configPath = join(os.tmpdir(), `parallel-code-subtask-${taskId}.json`);

    mockAtomicWriteFileSync.mockClear();
    coordinator.hydrateTask({
      id: taskId,
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/hydrated',
      agentId: 'agent-restart-1',
      coordinatorTaskId: 'coord-1',
      mcpConfigPath: configPath,
    });

    const rewrite = mockAtomicWriteFileSync.mock.calls.find((c) => c[0] === configPath);
    expect(rewrite).toBeDefined();
    if (!rewrite) throw new Error('expected config rewrite');
    const config = JSON.parse(rewrite[1] as string) as {
      mcpServers: { 'parallel-code': { env: Record<string, string> } };
    };
    const writtenToken = config.mcpServers['parallel-code'].env['PARALLEL_CODE_MCP_TOKEN'];
    expect(writtenToken).toBe('new-subtask-secret');
    expect(writtenToken).not.toBe('new-coordinator-secret');
  });

  it('waitForIdle resolves after agent output fires post-hydration', async () => {
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3002',
      'new-coordinator-secret',
      'new-subtask-secret',
      '/path/server.js',
    );

    const taskId = 'hydrated-restart-2';
    const agentId = 'agent-restart-2';
    const configPath = join(os.tmpdir(), `parallel-code-subtask-${taskId}.json`);

    coordinator.hydrateTask({
      id: taskId,
      name: 'hydrated-task',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/hydrated',
      worktreePath: '/tmp/hydrated',
      agentId,
      coordinatorTaskId: 'coord-1',
      mcpConfigPath: configPath,
    });

    // Simulate agent respawn: task transitions from exited → running
    const task = coordinator.getTask(taskId);
    expect(task).toBeDefined();
    if (!task) throw new Error('task not found after hydration');
    task.status = 'running';

    // Get the output callback registered during hydrateTask
    const hydratedCb = mockSubscribeToAgent.mock.calls.find((c) => c[0] === agentId)?.[1] as
      | ((encoded: string) => void)
      | undefined;
    expect(hydratedCb).toBeDefined();
    if (!hydratedCb) throw new Error('hydrateTask did not subscribe to agent');

    const waitPromise = coordinator.waitForIdle(taskId);
    hydratedCb(encode('Work done ❯ '));
    await expect(waitPromise).resolves.toEqual({ reason: 'idle' });
  });
});

// ─── #36: hydrateTask mcpConfigPath directory scoping ────────────────────────

describe('Coordinator hydrateTask — mcpConfigPath directory scoping', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtok',
      '/srv/app/.parallel-code/mcp-server.js',
    );
  });

  it('path traversal (../../etc/passwd-style) is rejected — mcpConfigPath is undefined, no config write', () => {
    coordinator.hydrateTask({
      id: 'task-traversal',
      name: 'evil',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/evil',
      worktreePath: '/tmp/evil',
      agentId: 'agent-evil',
      coordinatorTaskId: 'coord-1',
      mcpConfigPath: '../../etc/passwd',
    });

    expect(coordinator.getTask('task-traversal')?.mcpConfigPath).toBeUndefined();
    const evilWrite = mockAtomicWriteFileSync.mock.calls.find((c) =>
      (c[0] as string).includes('etc/passwd'),
    );
    expect(evilWrite).toBeUndefined();
  });

  it('right filename in wrong dir is rejected — mcpConfigPath is undefined', () => {
    const taskId = 'task-wrong-dir';
    coordinator.hydrateTask({
      id: taskId,
      name: 'wrong-dir',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/wrong-dir',
      worktreePath: '/tmp/wrong-dir',
      agentId: 'agent-wrong-dir',
      coordinatorTaskId: 'coord-1',
      mcpConfigPath: `/tmp/evil/parallel-code-subtask-${taskId}.json`,
    });

    expect(coordinator.getTask(taskId)?.mcpConfigPath).toBeUndefined();
  });

  it('correct host tmpdir path is accepted and config write occurs', () => {
    const taskId = 'task-valid-host';
    const validPath = join(os.tmpdir(), `parallel-code-subtask-${taskId}.json`);

    mockAtomicWriteFileSync.mockClear();
    coordinator.hydrateTask({
      id: taskId,
      name: 'valid-host',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/valid-host',
      worktreePath: '/tmp/valid-host',
      agentId: 'agent-valid-host',
      coordinatorTaskId: 'coord-1',
      mcpConfigPath: validPath,
    });

    expect(coordinator.getTask(taskId)?.mcpConfigPath).toBe(validPath);
    const configWrite = mockAtomicWriteFileSync.mock.calls.find((c) => c[0] === validPath);
    expect(configWrite).toBeDefined();
  });

  it('Docker mode: dirname(serverPath)/subtask-{id}.json is accepted and config write occurs', () => {
    const taskId = 'task-valid-docker';
    const serverPath = '/srv/app/.parallel-code/mcp-server.js';
    const dockerPath = join(dirname(serverPath), `subtask-${taskId}.json`);

    mockAtomicWriteFileSync.mockClear();
    coordinator.hydrateTask({
      id: taskId,
      name: 'valid-docker',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/valid-docker',
      worktreePath: '/tmp/valid-docker',
      agentId: 'agent-valid-docker',
      coordinatorTaskId: 'coord-1',
      mcpConfigPath: dockerPath,
    });

    expect(coordinator.getTask(taskId)?.mcpConfigPath).toBe(dockerPath);
    const configWrite = mockAtomicWriteFileSync.mock.calls.find((c) => c[0] === dockerPath);
    expect(configWrite).toBeDefined();
  });

  it('Docker mode: path in wrong dir is rejected — mcpConfigPath is undefined', () => {
    const taskId = 'task-evil-docker';
    const wrongPath = `/some/other/dir/subtask-${taskId}.json`;

    coordinator.hydrateTask({
      id: taskId,
      name: 'evil-docker',
      projectId: 'proj-1',
      projectRoot: '/tmp/project',
      branchName: 'task/evil-docker',
      worktreePath: '/tmp/evil-docker',
      agentId: 'agent-evil-docker',
      coordinatorTaskId: 'coord-1',
      mcpConfigPath: wrongPath,
    });

    expect(coordinator.getTask(taskId)?.mcpConfigPath).toBeUndefined();
  });
});

// ─── #39: Docker coordinator child-close isolation ────────────────────────────

describe('Coordinator closeTask — per-task config isolation (two sub-tasks)', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
    coordinator.setMCPServerInfo(
      'coord-1',
      'http://localhost:3001',
      'tok',
      'subtask-tok',
      '/path/server.js',
    );
  });

  it('closing task-1 deletes only its config; task-2 config and task-2 entry are untouched', async () => {
    mockCreateBackendTask
      .mockResolvedValueOnce({ id: 'task-1', branch_name: 'task/a', worktree_path: '/tmp/a' })
      .mockResolvedValueOnce({ id: 'task-2', branch_name: 'task/b', worktree_path: '/tmp/b' });

    await coordinator.createTask({ name: 'task-one', prompt: 'do', coordinatorTaskId: 'coord-1' });
    await coordinator.createTask({ name: 'task-two', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const config1 = coordinator.getTask('task-1')?.mcpConfigPath;
    const config2 = coordinator.getTask('task-2')?.mcpConfigPath;
    expect(config1).toBeDefined();
    expect(config2).toBeDefined();
    expect(config1).not.toBe(config2);

    mockUnlinkSync.mockClear();
    await coordinator.closeTask('task-1');

    // task-1's config was deleted
    expect(mockUnlinkSync).toHaveBeenCalledWith(config1);
    // task-2's config was NOT deleted
    expect(mockUnlinkSync).not.toHaveBeenCalledWith(config2);

    // task-2 is still present, task-1 is gone
    const tasks = coordinator.listTasks();
    expect(tasks.some((t) => t.id === 'task-2')).toBe(true);
    expect(tasks.some((t) => t.id === 'task-1')).toBe(false);
  });
});

// ─── Docker per-container sub-task tests (#31) ───────────────────────────────

describe('Coordinator Docker mode — per-container sub-tasks', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-docker-1',
      branch_name: 'task/docker-sub',
      worktree_path: '/tmp/project/.worktrees/task/docker-sub',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');

    // Register coordinator in Docker mode
    coordinator.registerCoordinator('coord-docker', 'proj-1', {
      worktreePath: '/tmp/project/.worktrees/task/coord',
    });
    coordinator.setDockerContainerName('coord-docker', 'parallel-code-abcdef123456');
    coordinator.setDockerImage('coord-docker', 'parallel-code-agent:latest');
    coordinator.setCoordinatorSpawnDefaults('coord-docker', 'claude', []);
  });

  it('createTask in Docker mode spawns via docker run (dockerMode: true), not docker exec', async () => {
    await coordinator.createTask({
      name: 'docker-sub-task',
      coordinatorTaskId: 'coord-docker',
    });

    expect(mockSpawnAgent).toHaveBeenCalledOnce();
    const spawnCall = mockSpawnAgent.mock.calls[0][1];

    // Must use dockerMode: true — never build 'docker exec' args manually
    expect(spawnCall.dockerMode).toBe(true);
    // Command is the agent command (claude), not 'docker'
    expect(spawnCall.command).toBe('claude');
    // Args do not contain 'exec'
    expect(spawnCall.args).not.toContain('exec');
    // Args do not contain the coordinator container name
    expect(spawnCall.args).not.toContain('parallel-code-abcdef123456');
  });

  it('createTask passes the coordinator Docker image to spawnAgent', async () => {
    await coordinator.createTask({
      name: 'docker-sub-task',
      coordinatorTaskId: 'coord-docker',
    });

    const spawnCall = mockSpawnAgent.mock.calls[0][1];
    expect(spawnCall.dockerImage).toBe('parallel-code-agent:latest');
  });

  it('createTask sets dockerMountWorktreeParent: true so coordinator .parallel-code/ is accessible', async () => {
    await coordinator.createTask({
      name: 'docker-sub-task',
      coordinatorTaskId: 'coord-docker',
    });

    const spawnCall = mockSpawnAgent.mock.calls[0][1];
    expect(spawnCall.dockerMountWorktreeParent).toBe(true);
  });

  it('createTask in non-Docker mode does not set dockerMode on spawnAgent', async () => {
    coordinator.registerCoordinator('coord-host', 'proj-1');
    coordinator.setCoordinatorSpawnDefaults('coord-host', 'claude', []);
    // No setDockerContainerName call — host mode

    mockCreateBackendTask.mockResolvedValueOnce({
      id: 'task-host-1',
      branch_name: 'task/host-sub',
      worktree_path: '/tmp/project/.worktrees/task/host-sub',
    });

    await coordinator.createTask({
      name: 'host-sub-task',
      coordinatorTaskId: 'coord-host',
    });

    const spawnCall = mockSpawnAgent.mock.calls[0][1];
    expect(spawnCall.dockerMode).toBeUndefined();
    expect(spawnCall.dockerImage).toBeUndefined();
    expect(spawnCall.command).toBe('claude');
  });

  it('setDockerImage stores the image on coordinator state', () => {
    coordinator.setDockerImage('coord-docker', 'my-custom-image:v2');
    // Verify through createTask spawn — indirectly tests the stored value
    // (direct state access not available, but spawnAgent mock captures it)
  });

  it('closeTask for a Docker sub-task does not call docker exec kill', async () => {
    const { killAgent } = await vi.importMock<typeof import('../ipc/pty.js')>('../ipc/pty.js');

    await coordinator.createTask({
      name: 'docker-sub-task',
      coordinatorTaskId: 'coord-docker',
    });

    const task = coordinator.listTasks().find((t) => t.name === 'docker-sub-task');
    if (!task) throw new Error('task not found');

    vi.clearAllMocks();
    await coordinator.closeTask(task.id);

    // killAgent is called (which internally calls stopDockerContainer in pty.ts)
    expect(killAgent).toHaveBeenCalledWith(expect.any(String));

    // docker exec should NOT be called for killing the inner process
    // (execFile is called only for git operations in cleanupTask, not docker exec kill)
    const dockerExecKillCall = mockExecFile.mock.calls.find(
      (c) =>
        c[0] === 'docker' && Array.isArray(c[1]) && c[1][0] === 'exec' && c[1].includes('kill'),
    );
    expect(dockerExecKillCall).toBeUndefined();
  });
});

// ─── waitForSignalDone requestId replay ──────────────────────────────────────

describe('Coordinator waitForSignalDone — requestId replay after transport failure', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it('same requestId returns cached result after signal is already consumed', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const task = coordinator.getTask('task-1');
    if (!task) throw new Error('task not found');
    task.signalDoneAt = new Date();
    task.signalDoneConsumed = false;

    const requestId = 'replay-test-id-1';
    // First call: consumes the signal
    const result1 = await coordinator.waitForSignalDone('coord-1', 500, requestId);
    expect(result1.taskId).toBe('task-1');
    expect(task.signalDoneConsumed).toBe(true);

    // Second call with same requestId: signal consumed, but result is replayed from cache
    const result2 = await coordinator.waitForSignalDone('coord-1', 100, requestId);
    expect(result2).toEqual(result1);
  });

  it('different requestId after signal is consumed blocks until timeout', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const task = coordinator.getTask('task-1');
    if (!task) throw new Error('task not found');
    task.signalDoneAt = new Date();
    task.signalDoneConsumed = false;

    // First call with requestId A consumes the signal
    await coordinator.waitForSignalDone('coord-1', 500, 'id-A');
    expect(task.signalDoneConsumed).toBe(true);

    // Second call with a new requestId: no unconsumed signal, no cache hit → times out
    const result2 = await coordinator.waitForSignalDone('coord-1', 50, 'id-B');
    expect(result2.timedOut).toBe(true);
  });

  it('waitForSignalDone without requestId still resolves from unconsumed signal', async () => {
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const task = coordinator.getTask('task-1');
    if (!task) throw new Error('task not found');
    task.signalDoneAt = new Date();
    task.signalDoneConsumed = false;

    // No requestId: backward-compatible path
    const result = await coordinator.waitForSignalDone('coord-1', 100);
    expect(result.taskId).toBe('task-1');
  });

  it('cached result for coord-A does not replay for coord-B with the same requestId', async () => {
    coordinator.registerCoordinator('coord-2', 'proj-1');

    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });
    const task = coordinator.getTask('task-1');
    if (!task) throw new Error('task not found');
    task.signalDoneAt = new Date();
    task.signalDoneConsumed = false;

    const requestId = 'shared-id';
    // coord-A consumes the signal and caches with key `coord-1:shared-id`
    const result1 = await coordinator.waitForSignalDone('coord-1', 500, requestId);
    expect(result1.taskId).toBe('task-1');

    // coord-B with same requestId must not replay coord-A's cached result
    const result2 = await coordinator.waitForSignalDone('coord-2', 50, requestId);
    expect(result2.timedOut).toBe(true);
  });

  it('same requestId returns cached timeout result immediately', async () => {
    vi.useFakeTimers();
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const requestId = 'timeout-replay-id';
    const firstWait = coordinator.waitForSignalDone('coord-1', 500, requestId);
    vi.advanceTimersByTime(500);
    const firstResult = await firstWait;

    expect(firstResult).toEqual({ remaining: 1, timedOut: true });

    const replay = coordinator.waitForSignalDone('coord-1', 500, requestId);
    let replayResult: Awaited<typeof replay> | undefined;
    replay.then((result) => {
      replayResult = result;
    });
    await Promise.resolve();

    expect(replayResult).toEqual(firstResult);
  });

  it('same requestId replays cached timeout after coordinator deregisters', async () => {
    vi.useFakeTimers();
    await coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' });

    const requestId = 'timeout-replay-after-deregister-id';
    const firstWait = coordinator.waitForSignalDone('coord-1', 500, requestId);
    vi.advanceTimersByTime(500);
    const firstResult = await firstWait;

    expect(firstResult).toEqual({ remaining: 1, timedOut: true });

    await coordinator.deregisterCoordinator('coord-1');

    await expect(coordinator.waitForSignalDone('coord-1', 500, requestId)).resolves.toEqual(
      firstResult,
    );
  });
});

// ─── removePreambleBlock unit tests ──────────────────────────────────────────

describe('Coordinator removePreambleBlock', () => {
  const strip = removePreambleBlock;

  const BLOCK = '<sub-task-mode>\nrules\n</sub-task-mode>';

  it('removes preamble block appended to existing content', () => {
    const result = strip(`existing content\n\n${BLOCK}`);
    expect(result).toBe('existing content');
  });

  it('preserves content after end marker', () => {
    const result = strip(`before\n\n${BLOCK}\n\nafter`);
    expect(result).toBe('before\n\nafter');
  });

  it('preserves content before preamble when no prior content exists', () => {
    const result = strip(`${BLOCK}\n\nafter`);
    expect(result).toBe('after');
  });

  it('returns empty string when file contains only preamble block', () => {
    const result = strip(BLOCK);
    expect(result).toBe('');
  });

  it('drops from start marker to EOF when end marker is absent (prevents preamble being committed)', () => {
    const content = 'before\n\n<sub-task-mode>\norphaned start';
    expect(strip(content)).toBe('before');
  });

  it('returns content unchanged when no preamble marker present', () => {
    const content = 'just a normal file\nno preamble here';
    expect(strip(content)).toBe(content);
  });
});

// ─── getTaskDiff — preamble-bearing files (#34) ───────────────────────────────

describe('Coordinator getTaskDiff — preamble-bearing files', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/worktree',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
    vi.mocked(getDiffBaseSha).mockResolvedValue('base-sha-abc');
  });

  it('preamble-only AGENTS.md is excluded from file list and diff output', async () => {
    await coordinator.createTask({ name: 'T', coordinatorTaskId: 'coord-1' });

    vi.mocked(getChangedFiles).mockResolvedValue([
      { path: 'AGENTS.md', status: 'M', lines_added: 5, lines_removed: 0, committed: true },
    ]);
    vi.mocked(getAllFileDiffs).mockResolvedValue(
      'diff --git a/AGENTS.md b/AGENTS.md\n@@ -1 +1,3 @@\n+<sub-task-mode>\n+rules\n+</sub-task-mode>\n',
    );

    // AGENTS.md contains only the injected preamble block
    const preambleContent = '<sub-task-mode>\nrules here\n</sub-task-mode>';
    mockFsReadFile.mockImplementation(async (p: unknown) => {
      if (String(p).includes('AGENTS.md')) return preambleContent;
      throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
    });
    mockExistsSync.mockImplementation((p?: unknown) => String(p).includes('AGENTS.md'));
    mockReadFileSync.mockReturnValue(preambleContent);

    // git show: base was empty; git diff --no-index: no diff (normalized == base).
    // Note: git diff --no-index is called WITHOUT opts, so promisify places the callback
    // in position 3 (optsOrCb). We detect which arg is the callback by checking typeof.
    mockExecFile.mockImplementation(
      (
        _cmd: string,
        _args: string[],
        optsOrCb: unknown,
        cbMaybe?: (e: Error | null, o: string, r: string) => void,
      ) => {
        const cb = (typeof optsOrCb === 'function' ? optsOrCb : cbMaybe) as (
          e: Error | null,
          o: string,
          r: string,
        ) => void;
        cb(null, '', '');
      },
    );

    const result = await coordinator.getTaskDiff('task-1');

    expect(result.files).toHaveLength(0);
    expect(result.diff).not.toContain('AGENTS.md');
    expect(result.diff).not.toContain('sub-task-mode');
  });

  it('AGENTS.md with user edit after preamble block shows only the user edit', async () => {
    await coordinator.createTask({ name: 'T', coordinatorTaskId: 'coord-1' });

    vi.mocked(getChangedFiles).mockResolvedValue([
      { path: 'AGENTS.md', status: 'M', lines_added: 8, lines_removed: 0, committed: true },
    ]);
    vi.mocked(getAllFileDiffs).mockResolvedValue(
      'diff --git a/AGENTS.md b/AGENTS.md\n--- a/AGENTS.md\n+++ b/AGENTS.md\n@@ -1 +1,8 @@\n+preamble and user content\n',
    );

    // Worktree: preamble block + user content after it
    const worktreeContent =
      '<sub-task-mode>\nrules\n</sub-task-mode>\n\n# User section added by sub-agent\n';
    mockFsReadFile.mockImplementation(async (p: unknown) => {
      if (String(p).includes('AGENTS.md')) return worktreeContent;
      throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
    });
    mockExistsSync.mockImplementation((p?: unknown) => String(p).includes('AGENTS.md'));
    mockReadFileSync.mockReturnValue(worktreeContent);

    const fakeDiff =
      'diff --git a/AGENTS.md b/AGENTS.md\n--- a/AGENTS.md\n+++ b/AGENTS.md\n@@ -0,0 +1 @@\n+# User section added by sub-agent\n';

    // git show has opts ({cwd}), git diff --no-index does not. Detect callback by type.
    mockExecFile.mockImplementation(
      (
        _cmd: string,
        args: string[],
        optsOrCb: unknown,
        cbMaybe?: (e: Error | null, o: string, r: string) => void,
      ) => {
        const cb = (typeof optsOrCb === 'function' ? optsOrCb : cbMaybe) as (
          e: Error | null,
          o: string,
          r: string,
        ) => void;
        if (args[0] === 'show') {
          cb(null, '', ''); // base was empty
        } else if (args[0] === 'diff') {
          // git diff exits with code 1 when files differ
          const err = Object.assign(new Error(''), { code: 1, stdout: fakeDiff });
          cb(err, fakeDiff, '');
        } else {
          cb(null, '', '');
        }
      },
    );

    const result = await coordinator.getTaskDiff('task-1');

    expect(result.files).toHaveLength(1);
    expect(result.diff).toContain('User section added by sub-agent');
    expect(result.diff).not.toContain('sub-task-mode');
  });

  it('AGENTS.md with user edit before preamble block also shows the user edit', async () => {
    await coordinator.createTask({ name: 'T', coordinatorTaskId: 'coord-1' });

    vi.mocked(getChangedFiles).mockResolvedValue([
      { path: 'AGENTS.md', status: 'M', lines_added: 6, lines_removed: 0, committed: true },
    ]);
    vi.mocked(getAllFileDiffs).mockResolvedValue(
      'diff --git a/AGENTS.md b/AGENTS.md\n@@ -1 +1,6 @@\n+mixed content\n',
    );

    // Worktree: user content before preamble
    const worktreeContent = '# My custom heading\n\n<sub-task-mode>\nrules\n</sub-task-mode>\n';
    mockFsReadFile.mockImplementation(async (p: unknown) => {
      if (String(p).includes('AGENTS.md')) return worktreeContent;
      throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
    });
    mockExistsSync.mockImplementation((p?: unknown) => String(p).includes('AGENTS.md'));
    mockReadFileSync.mockReturnValue(worktreeContent);

    const fakeDiff =
      'diff --git a/AGENTS.md b/AGENTS.md\n--- a/AGENTS.md\n+++ b/AGENTS.md\n@@ -0,0 +1 @@\n+# My custom heading\n';

    mockExecFile.mockImplementation(
      (
        _cmd: string,
        args: string[],
        optsOrCb: unknown,
        cbMaybe?: (e: Error | null, o: string, r: string) => void,
      ) => {
        const cb = (typeof optsOrCb === 'function' ? optsOrCb : cbMaybe) as (
          e: Error | null,
          o: string,
          r: string,
        ) => void;
        if (args[0] === 'show') {
          cb(null, '', '');
        } else if (args[0] === 'diff') {
          const err = Object.assign(new Error(''), { code: 1, stdout: fakeDiff });
          cb(err, fakeDiff, '');
        } else {
          cb(null, '', '');
        }
      },
    );

    const result = await coordinator.getTaskDiff('task-1');

    expect(result.files).toHaveLength(1);
    expect(result.diff).toContain('My custom heading');
    expect(result.diff).not.toContain('sub-task-mode');
  });

  it('settings.local.json preserves unrelated keys, shows only non-preamble changes', async () => {
    await coordinator.createTask({ name: 'T', coordinatorTaskId: 'coord-1' });

    const settingsRelPath = '.claude/settings.local.json';
    vi.mocked(getChangedFiles).mockResolvedValue([
      { path: settingsRelPath, status: 'M', lines_added: 4, lines_removed: 0, committed: true },
    ]);
    vi.mocked(getAllFileDiffs).mockResolvedValue(
      `diff --git a/${settingsRelPath} b/${settingsRelPath}\n@@ -1 +1,5 @@\n+settings\n`,
    );

    const settingsContent = JSON.stringify(
      {
        model: 'claude-opus-4-7',
        systemPrompt: '<sub-task-mode>\nrules\n</sub-task-mode>',
      },
      null,
      2,
    );
    mockFsReadFile.mockImplementation(async (p: unknown) => {
      if (String(p).includes('settings.local.json')) return settingsContent;
      throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
    });
    mockExistsSync.mockImplementation((p?: unknown) => String(p).includes('settings.local.json'));
    mockReadFileSync.mockReturnValue(settingsContent);

    const fakeDiff = `diff --git a/${settingsRelPath} b/${settingsRelPath}\n--- a/${settingsRelPath}\n+++ b/${settingsRelPath}\n@@ -1,5 +1,3 @@\n {\n+  "model": "claude-opus-4-7"\n }\n`;

    // git show has opts ({cwd}), git diff --no-index does not. Detect callback by type.
    mockExecFile.mockImplementation(
      (
        _cmd: string,
        args: string[],
        optsOrCb: unknown,
        cbMaybe?: (e: Error | null, o: string, r: string) => void,
      ) => {
        const cb = (typeof optsOrCb === 'function' ? optsOrCb : cbMaybe) as (
          e: Error | null,
          o: string,
          r: string,
        ) => void;
        if (args[0] === 'show') {
          cb(null, '{}', ''); // base had empty settings
        } else if (args[0] === 'diff') {
          const err = Object.assign(new Error(''), { code: 1, stdout: fakeDiff });
          cb(err, fakeDiff, '');
        } else {
          cb(null, '', '');
        }
      },
    );

    const result = await coordinator.getTaskDiff('task-1');

    expect(result.files).toHaveLength(1); // file has real change (model key)
    expect(result.diff).toContain('model');
    expect(result.diff).not.toContain('sub-task-mode');
    expect(result.diff).not.toContain('systemPrompt');
  });
});

// ─── deregisterCoordinator .mcp.json cleanup (#40) ───────────────────────────

describe('Coordinator deregisterCoordinator — .mcp.json cleanup', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    mockExistsSync.mockReturnValue(false);
    mockCreateBackendTask.mockResolvedValue({
      id: 'task-1',
      branch_name: 'task/test',
      worktree_path: '/tmp/test',
    });
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
    coordinator.setMcpJsonInfo('coord-1', '/tmp/.mcp.json', false);
  });

  it('removes only the parallel-code key and preserves other servers', () => {
    mockExistsSync.mockReturnValue(true);
    mockReadFileSync.mockReturnValue(
      JSON.stringify({
        mcpServers: {
          'my-server': { command: 'my-tool', args: [] },
          'parallel-code': { command: 'node', args: ['server.js'] },
        },
      }),
    );

    coordinator.deregisterCoordinator('coord-1');

    const writeCall = mockAtomicWriteFileSync.mock.calls.find(
      (c: unknown[]) => c[0] === '/tmp/.mcp.json',
    );
    expect(writeCall).toBeDefined();
    const written = JSON.parse(writeCall?.[1] as string) as {
      mcpServers: Record<string, unknown>;
    };
    expect(written.mcpServers['my-server']).toBeDefined();
    expect(written.mcpServers['parallel-code']).toBeUndefined();
    expect(mockUnlinkSync).not.toHaveBeenCalledWith('/tmp/.mcp.json');
  });

  it('deletes the file when parallel-code was the only entry', () => {
    mockExistsSync.mockReturnValue(true);
    mockReadFileSync.mockReturnValue(
      JSON.stringify({
        mcpServers: { 'parallel-code': { command: 'node', args: ['server.js'] } },
      }),
    );

    coordinator.deregisterCoordinator('coord-1');

    expect(mockUnlinkSync).toHaveBeenCalledWith('/tmp/.mcp.json');
    const writeCall = mockAtomicWriteFileSync.mock.calls.find(
      (c: unknown[]) => c[0] === '/tmp/.mcp.json',
    );
    expect(writeCall).toBeUndefined();
  });

  it('does not touch the filesystem when .mcp.json does not exist', () => {
    mockExistsSync.mockReturnValue(false);

    coordinator.deregisterCoordinator('coord-1');

    expect(mockAtomicWriteFileSync).not.toHaveBeenCalled();
    expect(mockUnlinkSync).not.toHaveBeenCalled();
  });

  it('preserves the file when it has additional top-level keys beyond mcpServers', () => {
    mockExistsSync.mockReturnValue(true);
    mockReadFileSync.mockReturnValue(
      JSON.stringify({
        mcpServers: { 'parallel-code': { command: 'node', args: [] } },
        someOtherKey: 'kept',
      }),
    );

    coordinator.deregisterCoordinator('coord-1');

    // File should be rewritten (not deleted) because someOtherKey remains
    const writeCall = mockAtomicWriteFileSync.mock.calls.find(
      (c: unknown[]) => c[0] === '/tmp/.mcp.json',
    );
    expect(writeCall).toBeDefined();
    const written = JSON.parse(writeCall?.[1] as string) as Record<string, unknown>;
    expect(written['someOtherKey']).toBe('kept');
    expect(mockUnlinkSync).not.toHaveBeenCalledWith('/tmp/.mcp.json');
  });
});

// ─── preload allowlist regression test ───────────────────────────────────────

describe('preload.cjs MCP channel allowlist', () => {
  it('contains all MCP coordinator IPC channels', async () => {
    const { readFileSync } = await vi.importActual<typeof import('fs')>('fs');
    const path = await import('node:path');
    const preloadPath = path.join(
      path.dirname(new URL(import.meta.url).pathname),
      '..',
      'preload.cjs',
    );
    const preload = readFileSync(preloadPath, 'utf8') as string;

    const required = [
      'mcp_task_created',
      'mcp_task_closed',
      'mcp_task_state_sync',
      'mcp_control_changed',
      'mcp_coordinator_notification_staged',
      'mcp_coordinator_orphaned_notification',
      'mcp_coordinator_registered',
      'mcp_coordinator_deregistered',
      'mcp_coordinator_notification_ack',
      'mcp_coordinated_task_prompt_delivered',
      'mcp_coordinated_task_closed',
    ];

    for (const channel of required) {
      expect(preload, `preload.cjs missing channel: ${channel}`).toContain(`'${channel}'`);
    }
  });
});

// ─── validateUUID / hydrateTask path-traversal rejection ─────────────────────

describe('validateUUID — rejects non-UUID ids in MCP IPC handler', () => {
  it('rejects ids containing path separators', async () => {
    const { validateUUID } = await import('./validation.js');
    expect(() => validateUUID('../../etc/passwd', 'id')).toThrow('must be a valid UUID');
  });

  it('rejects ids containing slashes', async () => {
    const { validateUUID } = await import('./validation.js');
    expect(() => validateUUID('task/1', 'id')).toThrow('must be a valid UUID');
  });

  it('accepts a valid UUID', async () => {
    const { validateUUID } = await import('./validation.js');
    const id = '550e8400-e29b-41d4-a716-446655440000';
    expect(validateUUID(id, 'id')).toBe(id);
  });
});

// ─── validateBranchName — additional git check-ref-format rules ───────────────

describe('validateBranchName — extended git rules', () => {
  it('rejects names starting with "/"', async () => {
    const { validateBranchName } = await import('./validation.js');
    expect(() => validateBranchName('/feat/bad')).toThrow('must not start with "/"');
  });

  it('rejects names ending with "/"', async () => {
    const { validateBranchName } = await import('./validation.js');
    expect(() => validateBranchName('feat/bad/')).toThrow('must not end with "/"');
  });

  it('rejects names ending with ".lock"', async () => {
    const { validateBranchName } = await import('./validation.js');
    expect(() => validateBranchName('feat.lock')).toThrow('.lock');
  });

  it('rejects names containing "@{"', async () => {
    const { validateBranchName } = await import('./validation.js');
    // { is caught by the shell metacharacter check
    expect(() => validateBranchName('feat@{bad}')).toThrow('invalid characters');
  });

  it('rejects names containing "//"', async () => {
    const { validateBranchName } = await import('./validation.js');
    expect(() => validateBranchName('feat//bad')).toThrow('must not contain "//"');
  });

  it('rejects names starting with "."', async () => {
    const { validateBranchName } = await import('./validation.js');
    expect(() => validateBranchName('.hidden')).toThrow('must not start with "."');
  });

  it('still accepts normal branch names', async () => {
    const { validateBranchName } = await import('./validation.js');
    expect(validateBranchName('feat/my-feature')).toBe('feat/my-feature');
  });
});

// ─── createTask vs concurrent deregisterCoordinator ──────────────────────────

describe('Coordinator createTask — deregister race', () => {
  let coordinator: InstanceType<typeof Coordinator>;

  beforeEach(() => {
    vi.clearAllMocks();
    coordinator = new Coordinator();
    coordinator.setWindow(mockWin);
    coordinator.setDefaultProject('proj-1', '/tmp/project');
    coordinator.registerCoordinator('coord-1', 'proj-1');
  });

  it('throws and cleans up the worktree when coordinator is deregistered mid-createTask', async () => {
    const { deleteTask } = await import('../ipc/tasks.js');
    mockCreateBackendTask.mockImplementation(async () => {
      coordinator.deregisterCoordinator('coord-1');
      return { id: 'task-99', branch_name: 'task/test', worktree_path: '/tmp/test-99' };
    });

    await expect(
      coordinator.createTask({ name: 'test', prompt: 'do', coordinatorTaskId: 'coord-1' }),
    ).rejects.toThrow('deregistered during task creation');

    expect(vi.mocked(deleteTask)).toHaveBeenCalledWith(
      expect.objectContaining({ branchName: 'task/test' }),
    );
    expect(coordinator.listTasks().find((t) => t.id === 'task-99')).toBeUndefined();
  });
});

// ─── waitForSignalDone — timeoutMs honored under network flapping ─────────────

describe('MCP client waitForSignalDone — timeout under flapping', () => {
  it('does not sleep longer than remaining timeout when retrying', async () => {
    const { MCPClient } = await import('./client.js');
    const client = new MCPClient('http://localhost:9999', 'tok', 'coord-id');

    const sleepDurations: number[] = [];
    vi.spyOn(global, 'setTimeout').mockImplementation((cb, ms) => {
      sleepDurations.push(ms as number);
      (cb as () => void)();
      return 0 as unknown as ReturnType<typeof setTimeout>;
    });

    vi.spyOn(client as unknown as { request: () => unknown }, 'request').mockRejectedValue(
      new TypeError('fetch failed'),
    );

    await expect(client.waitForSignalDone('coord-id', 500)).rejects.toThrow();

    // No individual sleep should have exceeded the timeout window
    for (const d of sleepDurations) {
      expect(d).toBeLessThanOrEqual(600); // small buffer over 500ms timeout
    }

    vi.restoreAllMocks();
  });
});