fix(mcp): fix stale task status and missing exit indicator in get_task_output

Three improvements to make agent exit visible to coordinators:

1. Export hasAgentSession() from pty.ts — lets the orchestrator do a
   synchronous liveness check without a round-trip through the event bus.

2. getTaskStatus proactive check: if the PTY session is gone but the task
   still shows a live status (can happen when the renderer re-spawns an
   agent, killing the old one without firing an exit event), mark it exited
   immediately so the caller doesn't see stale "running".

3. getTaskOutput exit indicator: append "[Process exited with code X
   (signal Y)]" when the agent is dead. Previously the last output buffer
   showed "almost done thinking" with no indication the process had exited.

Also capture exitSignal in OrchestratedTask/ApiTaskDetail so coordinators
can distinguish SIGHUP (129) from clean exits.

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

Author: brooksc

electron/ipc/pty.ts

@@ -460,6 +460,11 @@ export function getActiveAgentIds(): string[] {
   return Array.from(sessions.keys());
 }
 
+/** Check whether a PTY session exists for this agent (i.e. process is alive). */
+export function hasAgentSession(agentId: string): boolean {
+  return sessions.has(agentId);
+}
+
 /** Return metadata for a specific agent, or null if not found. */
 export function getAgentMeta(
   agentId: string,

electron/mcp/orchestrator.ts

@@ -11,6 +11,7 @@ import {
   subscribeToAgent,
   unsubscribeFromAgent,
   getAgentScrollback,
+  hasAgentSession,
   onPtyEvent,
 } from '../ipc/pty.js';
 import { getChangedFiles, getAllFileDiffs, mergeTask as gitMergeTask } from '../ipc/git.js';
@@ -40,9 +41,10 @@ export class Orchestrator {
     onPtyEvent('exit', (agentId, data) => {
       for (const task of this.tasks.values()) {
         if (task.agentId === agentId) {
-          const { exitCode } = (data ?? {}) as { exitCode?: number };
+          const { exitCode, signal } = (data ?? {}) as { exitCode?: number; signal?: number };
           task.status = 'exited';
           task.exitCode = exitCode ?? null;
+          task.exitSignal = signal !== undefined ? String(signal) : null;
           // Resolve any idle waiters so they don't hang
           const resolvers = this.idleResolvers.get(task.id);
           if (resolvers?.length) {
@@ -109,6 +111,7 @@ export class Orchestrator {
       coordinatorTaskId: coordinatorId,
       status: 'creating',
       exitCode: null,
+      exitSignal: null,
     };
 
     this.tasks.set(task.id, task);
@@ -210,6 +213,16 @@ export class Orchestrator {
   getTaskStatus(taskId: string): ApiTaskDetail | null {
     const task = this.tasks.get(taskId);
     if (!task) return null;
+
+    // Proactive liveness check: if the PTY session is gone but the task still
+    // shows a live status, the exit event was suppressed (e.g. the renderer
+    // spawned a new session with the same agentId, killing the old one without
+    // firing an exit event). Sync the status here so callers always get a
+    // consistent view without waiting for the next PTY event.
+    if (task.status !== 'exited' && task.status !== 'error' && !hasAgentSession(task.agentId)) {
+      task.status = 'exited';
+    }
+
     return {
       id: task.id,
       name: task.name,
@@ -220,6 +233,7 @@ export class Orchestrator {
       status: task.status,
       coordinatorTaskId: task.coordinatorTaskId,
       exitCode: task.exitCode,
+      exitSignal: task.exitSignal,
       pendingPrompt: task.pendingPrompt,
     };
   }
@@ -295,11 +309,21 @@ export class Orchestrator {
 
     // Try scrollback buffer first, fall back to tail buffer
     const scrollback = getAgentScrollback(task.agentId);
-    if (scrollback) {
-      const decoded = Buffer.from(scrollback, 'base64').toString('utf8');
-      return stripAnsi(decoded);
+    const raw = scrollback
+      ? Buffer.from(scrollback, 'base64').toString('utf8')
+      : (this.tailBuffers.get(task.agentId) ?? '');
+
+    let output = stripAnsi(raw);
+
+    // Append a clear exit notice so callers don't interpret stale "last words"
+    // as the current state of a running agent.
+    if (task.status === 'exited' || (task.status !== 'error' && !hasAgentSession(task.agentId))) {
+      const code = task.exitCode !== null ? task.exitCode : '?';
+      const sig = task.exitSignal ? ` (signal ${task.exitSignal})` : '';
+      output += `\n\n[Process exited with code ${code}${sig}]`;
     }
-    return stripAnsi(this.tailBuffers.get(task.agentId) ?? '');
+
+    return output;
   }
 
   async mergeTask(

electron/mcp/types.ts

@@ -10,6 +10,7 @@ export interface OrchestratedTask {
   coordinatorTaskId: string;
   status: 'creating' | 'running' | 'idle' | 'exited' | 'error';
   exitCode: number | null;
+  exitSignal: string | null;
   pendingPrompt?: string;
 }
 
@@ -71,6 +72,7 @@ export interface ApiTaskDetail extends ApiTaskSummary {
   projectId: string;
   agentId: string;
   exitCode: number | null;
+  exitSignal: string | null;
   pendingPrompt?: string;
 }