Add sub-task self-landing coordinator flow

electron/ipc/channels.ts

@@ -157,6 +157,7 @@ export enum IPC {
   MCP_TaskCreated = 'mcp_task_created',
   MCP_TaskClosed = 'mcp_task_closed',
   MCP_TaskStateSync = 'mcp_task_state_sync',
+  MCP_TaskLandingReviewCleared = 'mcp_task_landing_review_cleared',
   MCP_ControlChanged = 'mcp_control_changed',
   // Coordinator notifications (main → renderer)
   MCP_CoordinatorNotificationStaged = 'mcp_coordinator_notification_staged',

electron/ipc/pty.test.ts

@@ -755,6 +755,30 @@ describe('spawnAgent session reattach', () => {
     ).not.toThrow();
     expect(mockPtySpawn).toHaveBeenCalledTimes(1);
   });
+
+  it('replaces an existing same-id PTY when attachExisting is explicitly false', () => {
+    const win = createMockWindow();
+    const agentId = 'agent-replace';
+    const args = buildSpawnArgs({
+      agentId,
+      command: 'claude',
+      args: [],
+      dockerMode: false,
+      onOutput: { __CHANNEL_ID__: 'channel-1' },
+    });
+
+    spawnAgent(win, args);
+    const oldProc = mockPtySpawn.mock.results[0].value as ReturnType<typeof mockPtySpawn>;
+
+    spawnAgent(win, {
+      ...args,
+      attachExisting: false,
+      onOutput: { __CHANNEL_ID__: 'channel-2' },
+    });
+
+    expect(oldProc.kill).toHaveBeenCalled();
+    expect(mockPtySpawn).toHaveBeenCalledTimes(2);
+  });
 });
 
 describe('validateCommand', () => {

electron/ipc/register-mcp.test.ts

@@ -310,6 +310,7 @@ const VALID_ARGS = {
   coordinatorTaskId: TEST_COORDINATOR_ID,
   projectId: 'proj-1',
   projectRoot: '/absolute/project',
+  coordinatorBranch: 'task/coordinator-work',
   worktreePath: '/absolute/worktree',
   agentArgs: ['--flag', 'value'],
   dockerContainerName: 'my-container',
@@ -356,6 +357,18 @@ describe('Layer 4 — StartMCPServer input validation', () => {
     expect(copyFileSpy).not.toHaveBeenCalled();
   });
 
+  it('rejects invalid coordinatorBranch', () => {
+    const writeFileSpy = vi.spyOn(fs, 'writeFileSync');
+    const copyFileSpy = vi.spyOn(fs, 'copyFileSync');
+
+    expect(() =>
+      validateStartMCPServerArgs({ ...VALID_ARGS, coordinatorBranch: 'bad branch' }),
+    ).toThrow('coordinatorBranch');
+
+    expect(writeFileSpy).not.toHaveBeenCalled();
+    expect(copyFileSpy).not.toHaveBeenCalled();
+  });
+
   it('rejects agentArgs containing a non-string element', () => {
     const writeFileSpy = vi.spyOn(fs, 'writeFileSync');
     const copyFileSpy = vi.spyOn(fs, 'copyFileSync');

electron/ipc/register.ts

@@ -177,6 +177,9 @@ export function validateStartMCPServerArgs(args: Record<string, unknown>): void
   assertString(args.projectId, 'projectId');
   validatePath(args.projectRoot, 'projectRoot');
   if (args.worktreePath !== undefined) validatePath(args.worktreePath, 'worktreePath');
+  if (args.coordinatorBranch !== undefined) {
+    validateBranchName(args.coordinatorBranch, 'coordinatorBranch');
+  }
   if (args.agentCommand !== undefined) assertString(args.agentCommand, 'agentCommand');
   if (args.agentArgs !== undefined) assertStringArray(args.agentArgs, 'agentArgs');
   assertOptionalBoolean(args.skipPermissions, 'skipPermissions');
@@ -1180,10 +1183,22 @@ export function registerAllHandlers(win: BrowserWindow): void {
 
     ipcMain.handle(
       IPC.MCP_CoordinatorRegistered,
-      (_e, args: { coordinatorTaskId: string; projectId: string; worktreePath?: string }) => {
+      (
+        _e,
+        args: {
+          coordinatorTaskId: string;
+          projectId: string;
+          coordinatorBranch?: string;
+          worktreePath?: string;
+        },
+      ) => {
         assertString(args.coordinatorTaskId, 'coordinatorTaskId');
         assertString(args.projectId, 'projectId');
+        if (args.coordinatorBranch !== undefined) {
+          validateBranchName(args.coordinatorBranch, 'coordinatorBranch');
+        }
         coordinator?.registerCoordinator(args.coordinatorTaskId, args.projectId, {
+          branchName: args.coordinatorBranch,
           worktreePath: args.worktreePath,
         });
       },
@@ -1254,6 +1269,11 @@ export function registerAllHandlers(win: BrowserWindow): void {
       },
     );
 
+    ipcMain.handle(IPC.MCP_TaskLandingReviewCleared, (_e, args: { taskId: string }) => {
+      assertString(args.taskId, 'taskId');
+      coordinator?.markTaskReviewed(args.taskId);
+    });
+
     ipcMain.handle(
       IPC.MCP_CoordinatedTaskClosed,
       (_e, args: { taskId: string; coordinatorTaskId: string }) => {
@@ -1280,7 +1300,13 @@ export function registerAllHandlers(win: BrowserWindow): void {
           agentId?: string;
           signalDoneAt?: string;
           signalDoneConsumed?: boolean;
+          verification?: import('../mcp/types.js').SubtaskVerification;
+          landingState?: import('../mcp/types.js').LandingState;
+          landingReason?: string;
+          landingSummary?: string;
+          landedMetadata?: import('../mcp/types.js').LandedMetadata;
           mcpConfigPath?: string;
+          agentCommand?: string;
           preambleFileExistedBefore?: boolean;
         },
       ) => {
@@ -1296,7 +1322,8 @@ export function registerAllHandlers(win: BrowserWindow): void {
         assertString(args.coordinatorTaskId, 'coordinatorTaskId');
         validateUUID(args.coordinatorTaskId, 'coordinatorTaskId');
         if (!coordinator) throw new Error('coordinator mode not initialized');
-        coordinator.hydrateTask({
+        if (args.agentCommand !== undefined) assertString(args.agentCommand, 'agentCommand');
+        const result = coordinator.hydrateTask({
           id: args.id,
           name: args.name,
           projectId: args.projectId,
@@ -1309,13 +1336,20 @@ export function registerAllHandlers(win: BrowserWindow): void {
           controlledBy: args.controlledBy,
           signalDoneAt: args.signalDoneAt,
           signalDoneConsumed: args.signalDoneConsumed,
+          verification: args.verification,
+          landingState: args.landingState,
+          landingReason: args.landingReason,
+          landingSummary: args.landingSummary,
+          landedMetadata: args.landedMetadata,
           mcpConfigPath: args.mcpConfigPath,
+          agentCommand: args.agentCommand,
           preambleFileExistedBefore: args.preambleFileExistedBefore,
         });
         // Signal to renderer that MCP hydration is complete — gates TerminalView auto-spawn.
         if (!win.isDestroyed()) {
           win.webContents.send(IPC.MCP_TaskHydrated, { taskId: args.id });
         }
+        return result;
       },
     );
   }
@@ -1361,6 +1395,7 @@ export function registerAllHandlers(win: BrowserWindow): void {
         coordinatorTaskId: string;
         projectId: string;
         projectRoot: string;
+        coordinatorBranch?: string;
         worktreePath?: string;
         skipPermissions?: boolean;
         propagateSkipPermissions?: boolean;
@@ -1405,6 +1440,7 @@ export function registerAllHandlers(win: BrowserWindow): void {
       // so create_task / list_tasks know about it. Idempotent — safe to call on restore.
       coordinator.setDefaultProject(args.projectId, args.projectRoot, args.coordinatorTaskId);
       coordinator.registerCoordinator(args.coordinatorTaskId, args.projectId, {
+        branchName: args.coordinatorBranch,
         worktreePath: args.worktreePath,
         skipPermissions: Boolean(args.skipPermissions && args.propagateSkipPermissions),
       });

electron/mcp/client.ts

@@ -8,6 +8,8 @@ import type {
   ApiDiffResult,
   ApiMergeResult,
   ApiReviewAndMergeResult,
+  ApiLandSelfResult,
+  LandSelfInput,
   WaitForSignalDoneResult,
 } from './types.js';
 
@@ -106,19 +108,32 @@ export class MCPClient {
   }
 
   async signalDone(taskId: string): Promise<void> {
-    const url = `${this.baseUrl}/api/tasks/${encodeURIComponent(taskId)}/done`;
+    await this.taskOwnerRequest('POST', `/api/tasks/${encodeURIComponent(taskId)}/done`, {});
+  }
+
+  async landSelf(taskId: string, input: LandSelfInput): Promise<ApiLandSelfResult> {
+    return this.taskOwnerRequest<ApiLandSelfResult>(
+      'POST',
+      `/api/tasks/${encodeURIComponent(taskId)}/land`,
+      input,
+    );
+  }
+
+  private async taskOwnerRequest<T>(method: string, path: string, body: unknown): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
     const headers: Record<string, string> = {
       Authorization: `Bearer ${this.token}`,
       'Content-Type': 'application/json',
     };
     // Per-task done token is sent as X-Done-Token so the server can verify task ownership
     // without needing per-task bearer token classification.
     if (this.doneToken) headers['X-Done-Token'] = this.doneToken;
-    const res = await fetch(url, { method: 'POST', headers, body: '{}' });
+    const res = await fetch(url, { method, headers, body: JSON.stringify(body) });
     if (!res.ok) {
       const text = await res.text().catch(() => '');
-      throw new Error(`API POST /api/tasks/.../done failed (${res.status}): ${text}`);
+      throw new Error(`API ${method} ${path} failed (${res.status}): ${text}`);
     }
+    return (await res.json()) as T;
   }
 
   async waitForSignalDone(