feat(mcp): task visibility, pilot/co-pilot control, and expanded create_task options

- Coordinator sub-tasks now appear as individual sidebar panels
- Pilot/co-pilot control handoff with visual banner
- create_task exposes skipPermissions and gitIsolation
- Multiple bug fixes and tests

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: brooksc

electron/mcp/client.ts

@@ -16,11 +16,19 @@ export class MCPClient {
       'Content-Type': 'application/json',
     };
 
-    const res = await fetch(url, {
-      method,
-      headers,
-      body: body !== undefined ? JSON.stringify(body) : undefined,
-    });
+    let res: Response;
+    try {
+      res = await fetch(url, {
+        method,
+        headers,
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+      });
+    } catch (err) {
+      const cause = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `Cannot reach Parallel Code at ${this.baseUrl}. ` + `Is the app running? (${cause})`,
+      );
+    }
 
     if (!res.ok) {
       const text = await res.text().catch(() => '');
@@ -34,6 +42,8 @@ export class MCPClient {
     name: string;
     prompt?: string;
     projectId?: string;
+    skipPermissions?: boolean;
+    gitIsolation?: 'worktree' | 'direct' | 'none';
   }): Promise<ApiTaskDetail> {
     return this.request<ApiTaskDetail>('POST', '/api/tasks', opts);
   }

electron/mcp/orchestrator.test.ts

@@ -0,0 +1,212 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { BrowserWindow } from 'electron';
+
+// --- hoisted mocks (must be before any imports that use them) ---
+const {
+  mockCreateBackendTask,
+  mockDeleteTask,
+  mockWriteToAgent,
+  mockKillAgent,
+  mockOnPtyEvent,
+  spawnListeners,
+  exitListeners,
+} = vi.hoisted(() => {
+  // Track registered listeners so tests can fire them
+  const spawnListeners: Array<(agentId: string) => void> = [];
+  const exitListeners: Array<(agentId: string, data?: unknown) => void> = [];
+
+  const mockCreateBackendTask = vi.fn().mockResolvedValue({
+    id: 'task-abc',
+    branch_name: 'task/test-abc',
+    worktree_path: '/workspace/.worktrees/test',
+  });
+  const mockDeleteTask = vi.fn().mockResolvedValue(undefined);
+  const mockWriteToAgent = vi.fn();
+  const mockKillAgent = vi.fn();
+
+  const mockOnPtyEvent = vi.fn((event: string, listener: (id: string, data?: unknown) => void) => {
+    if (event === 'spawn') spawnListeners.push(listener as (id: string) => void);
+    if (event === 'exit') exitListeners.push(listener);
+    return () => {};
+  });
+
+  return {
+    mockCreateBackendTask,
+    mockDeleteTask,
+    mockWriteToAgent,
+    mockKillAgent,
+    mockOnPtyEvent,
+    spawnListeners,
+    exitListeners,
+  };
+});
+
+vi.mock('../ipc/tasks.js', () => ({
+  createTask: mockCreateBackendTask,
+  deleteTask: mockDeleteTask,
+}));
+
+vi.mock('../ipc/pty.js', () => ({
+  writeToAgent: mockWriteToAgent,
+  killAgent: mockKillAgent,
+  subscribeToAgent: vi.fn().mockReturnValue(true),
+  unsubscribeFromAgent: vi.fn(),
+  getAgentScrollback: vi.fn().mockReturnValue(null),
+  onPtyEvent: mockOnPtyEvent,
+}));
+
+vi.mock('../ipc/git.js', () => ({
+  getChangedFiles: vi.fn().mockResolvedValue([]),
+  getAllFileDiffs: vi.fn().mockResolvedValue(''),
+  mergeTask: vi.fn().mockResolvedValue({
+    main_branch: 'main',
+    lines_added: 0,
+    lines_removed: 0,
+  }),
+}));
+
+import { Orchestrator } from './orchestrator.js';
+
+function mockWindow(): BrowserWindow {
+  return {
+    isDestroyed: vi.fn(() => false),
+    webContents: { send: vi.fn() },
+  } as unknown as BrowserWindow;
+}
+
+async function makeOrchestratorWithTask(): Promise<{ orch: Orchestrator; taskId: string }> {
+  const orch = new Orchestrator();
+  orch.setWindow(mockWindow());
+  orch.setDefaultProject('proj-1', '/workspace', 'coord-1');
+
+  const task = await orch.createTask({ name: 'test-task', coordinatorTaskId: 'coord-1' });
+  const taskId = task.id;
+
+  // Simulate the renderer spawning the agent (triggers onPtyEvent 'spawn')
+  for (const listener of spawnListeners) {
+    listener(task.agentId);
+  }
+
+  return { orch, taskId };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  spawnListeners.length = 0;
+  exitListeners.length = 0;
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('Orchestrator.listTasks', () => {
+  it('returns an empty list when no tasks exist', () => {
+    const orch = new Orchestrator();
+    expect(orch.listTasks()).toEqual([]);
+  });
+
+  it('includes a task after createTask', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    const list = orch.listTasks();
+    expect(list).toHaveLength(1);
+    expect(list[0].id).toBe(taskId);
+    expect(list[0].name).toBe('test-task');
+  });
+});
+
+describe('Orchestrator control handoff — sendPrompt', () => {
+  it('sends the prompt normally when no control override is set', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    await orch.sendPrompt(taskId, 'do something');
+    expect(mockWriteToAgent).toHaveBeenCalledWith(expect.any(String), 'do something');
+  });
+
+  it('throws when task is under human control', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    orch.setTaskControl(taskId, 'human');
+    await expect(orch.sendPrompt(taskId, 'do something')).rejects.toThrow(/human control/);
+  });
+
+  it('resumes sending after control is returned to orchestrator', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    orch.setTaskControl(taskId, 'human');
+    orch.setTaskControl(taskId, 'orchestrator');
+    await orch.sendPrompt(taskId, 'back in action');
+    expect(mockWriteToAgent).toHaveBeenCalledWith(expect.any(String), 'back in action');
+  });
+
+  it('throws for unknown task id', async () => {
+    const orch = new Orchestrator();
+    await expect(orch.sendPrompt('nonexistent', 'hello')).rejects.toThrow(/not found/);
+  });
+});
+
+describe('Orchestrator control handoff — waitForIdle', () => {
+  it('resolves immediately when task is already idle', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    // Manually set status to idle (simulating output detection)
+    const task = orch.getTask(taskId);
+    if (task) task.status = 'idle';
+    await expect(orch.waitForIdle(taskId, 100)).resolves.toBeUndefined();
+  });
+
+  it('resolves immediately when human has control (orchestrator paused)', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    orch.setTaskControl(taskId, 'human');
+    await expect(orch.waitForIdle(taskId, 100)).resolves.toBeUndefined();
+  });
+
+  it('resolves pending waiters when control is returned to orchestrator', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    // Task is running — waitForIdle should block
+    const task = orch.getTask(taskId);
+    if (task) task.status = 'running';
+
+    const waited = orch.waitForIdle(taskId, 10_000);
+    // Taking human control resolves it immediately
+    orch.setTaskControl(taskId, 'human');
+    await expect(waited).resolves.toBeUndefined();
+  });
+
+  it('times out if the agent never becomes idle', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    const task = orch.getTask(taskId);
+    if (task) task.status = 'running';
+    await expect(orch.waitForIdle(taskId, 10)).rejects.toThrow(/[Tt]imed out/);
+  });
+
+  it('rejects for unknown task id', async () => {
+    const orch = new Orchestrator();
+    await expect(orch.waitForIdle('nonexistent', 100)).rejects.toThrow(/not found/);
+  });
+});
+
+describe('Orchestrator task status after PTY events', () => {
+  it('marks task exited when PTY exit fires for its agent', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    const task = orch.getTask(taskId);
+    expect(task).toBeTruthy();
+
+    const agentId = task?.agentId ?? '';
+    for (const listener of exitListeners) {
+      listener(agentId, { exitCode: 0 });
+    }
+
+    expect(orch.getTask(taskId)?.status).toBe('exited');
+    expect(orch.getTask(taskId)?.exitCode).toBe(0);
+  });
+
+  it('resolves pending waitForIdle when task exits', async () => {
+    const { orch, taskId } = await makeOrchestratorWithTask();
+    const task = orch.getTask(taskId);
+    if (task) task.status = 'running';
+
+    const waited = orch.waitForIdle(taskId, 10_000);
+    const agentId = task?.agentId ?? '';
+    for (const listener of exitListeners) {
+      listener(agentId, { exitCode: 1 });
+    }
+    await expect(waited).resolves.toBeUndefined();
+  });
+});