fix: hydrate backend Coordinator.tasks on app restart

Author: brooksc

electron/ipc/channels.ts

@@ -156,4 +156,5 @@ export enum IPC {
   MCP_CoordinatorNotificationDropAck = 'mcp_coordinator_notification_drop_ack',
   MCP_CoordinatedTaskPromptDelivered = 'mcp_coordinated_task_prompt_delivered',
   MCP_CoordinatorRestageAfterUserSend = 'mcp_coordinator_restage_after_user_send',
+  MCP_HydrateCoordinatedTask = 'mcp_hydrate_coordinated_task',
 }

electron/ipc/register.ts

@@ -1217,6 +1217,42 @@ export function registerAllHandlers(win: BrowserWindow): void {
         coordinator?.rescheduleRestageTimer(args.coordinatorTaskId);
       },
     );
+
+    ipcMain.handle(
+      IPC.MCP_HydrateCoordinatedTask,
+      (
+        _e,
+        args: {
+          id: string;
+          name: string;
+          projectId: string;
+          projectRoot: string;
+          branchName: string;
+          baseBranch?: string;
+          worktreePath: string;
+          coordinatorTaskId: string;
+        },
+      ) => {
+        assertString(args.id, 'id');
+        assertString(args.name, 'name');
+        assertString(args.projectId, 'projectId');
+        validatePath(args.projectRoot, 'projectRoot');
+        assertString(args.branchName, 'branchName');
+        validatePath(args.worktreePath, 'worktreePath');
+        assertString(args.coordinatorTaskId, 'coordinatorTaskId');
+        coordinator?.hydrateTask({
+          id: args.id,
+          name: args.name,
+          projectId: args.projectId,
+          projectRoot: args.projectRoot,
+          branchName: args.branchName,
+          baseBranch: args.baseBranch,
+          worktreePath: args.worktreePath,
+          agentId: crypto.randomUUID(),
+          coordinatorTaskId: args.coordinatorTaskId,
+        });
+      },
+    );
   }
 
   // Enable coordinator mode: lazily import the Coordinator module and register handlers.

electron/mcp/coordinator.ts

@@ -866,6 +866,34 @@ export class Coordinator {
     return this.tasks.get(taskId);
   }
 
+  hydrateTask(opts: {
+    id: string;
+    name: string;
+    projectId: string;
+    projectRoot: string;
+    branchName: string;
+    baseBranch?: string;
+    worktreePath: string;
+    agentId: string;
+    coordinatorTaskId: string;
+  }): void {
+    if (this.tasks.has(opts.id)) return;
+    const task: CoordinatedTask = {
+      id: opts.id,
+      name: opts.name,
+      projectId: opts.projectId,
+      projectRoot: opts.projectRoot,
+      branchName: opts.branchName,
+      baseBranch: opts.baseBranch,
+      worktreePath: opts.worktreePath,
+      agentId: opts.agentId,
+      coordinatorTaskId: opts.coordinatorTaskId,
+      status: 'exited',
+      exitCode: null,
+    };
+    this.tasks.set(task.id, task);
+  }
+
   registerCoordinator(coordinatorTaskId: string, projectId: string, worktreePath?: string): void {
     if (this.coordinators.has(coordinatorTaskId)) return;
     this.coordinators.set(coordinatorTaskId, {

src/App.tsx

@@ -347,6 +347,27 @@ function App() {
       });
     }
 
+    // Hydrate backend coordinator task registry with persisted child tasks so MCP
+    // tools (list_tasks, send_prompt, close_task, etc.) work after app restart.
+    for (const taskId of [...store.taskOrder, ...store.collapsedTaskOrder]) {
+      const task = store.tasks[taskId];
+      if (!task?.coordinatedBy) continue;
+      const projectRoot = store.projects.find((p) => p.id === task.projectId)?.path;
+      if (!projectRoot) continue;
+      invoke(IPC.MCP_HydrateCoordinatedTask, {
+        id: task.id,
+        name: task.name,
+        projectId: task.projectId,
+        projectRoot,
+        branchName: task.branchName,
+        baseBranch: task.baseBranch,
+        worktreePath: task.worktreePath,
+        coordinatorTaskId: task.coordinatedBy,
+      }).catch((err) => {
+        console.warn(`[MCP] Failed to hydrate coordinated task ${taskId}:`, err);
+      });
+    }
+
     // Restore plan content for tasks that had a plan file before restart
     for (const taskId of [...store.taskOrder, ...store.collapsedTaskOrder]) {
       const task = store.tasks[taskId];