claude-ws 0.3.97 → 0.3.99

package/src/lib/agent-manager.ts

@@ -15,6 +15,7 @@ import { EventEmitter } from 'events';
 import { existsSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { homedir } from 'os';
+import { normalize } from 'path';
 import { query, type Query } from '@anthropic-ai/claude-agent-sdk';
 import type { ClaudeOutput } from '../types';
 import { adaptSDKMessage, isValidSDKMessage, type BackgroundShellInfo, type SDKResultMessage } from './sdk-event-adapter';
@@ -224,8 +225,10 @@ interface AgentEvents {
   stderr: (data: { attemptId: string; content: string }) => void;
   exit: (data: { attemptId: string; code: number | null }) => void;
   question: (data: { attemptId: string; toolUseId: string; questions: unknown[] }) => void;
+  questionResolved: (data: { attemptId: string }) => void;
   backgroundShell: (data: { attemptId: string; shell: BackgroundShellInfo }) => void;
   trackedProcess: (data: { attemptId: string; pid: number; command: string; logFile?: string }) => void;
+  promptTooLong: (data: { attemptId: string }) => void;
 }
 
 export interface AgentStartOptions {
@@ -413,6 +416,30 @@ Your task is INCOMPLETE until:\n1. File exists with valid content\n2. You have R
         log.debug({ path: `${projectPath}/.mcp.json` }, 'No MCP config found');
       }
 
+      // Resolve claude executable path for SDK (Windows only)
+      // On Windows, the SDK defaults to running its bundled cli.js via `bun cli.js`,
+      // which causes EPERM on C:\Windows\System32\ due to a Bun PATH-reading bug.
+      // Fix: pass the real claude.exe path directly so the SDK spawns it as a native binary.
+      // On other platforms (Linux/macOS), leave undefined so SDK uses its default.
+      const resolvedClaudePath = (() => {
+        if (process.platform !== 'win32') return undefined;
+        const envPath = process.env.CLAUDE_PATH;
+        if (envPath && existsSync(normalize(envPath))) {
+          return normalize(envPath);
+        }
+        // Fallback: search common Windows locations
+        const home = process.env.USERPROFILE || process.env.HOME || '';
+        const candidates = [
+          join(home, '.local', 'bin', 'claude.exe'),
+          join(home, 'AppData', 'Local', 'Programs', 'claude', 'claude.exe'),
+        ];
+        for (const c of candidates) {
+          if (existsSync(c)) return c;
+        }
+        return undefined;
+
+      })();
+
       // Configure SDK query options
       // resumeSessionAt: resume conversation at specific message UUID (for rewind)
       // Model priority: provided model > DEFAULT_MODEL ('opus')
@@ -525,10 +552,14 @@ Your task is INCOMPLETE until:\n1. File exists with valid content\n2. You have R
         ? `You are powered by the model named ${modelDisplayName}. The exact model ID is ${effectiveModel}.`
         : `You are powered by the model ${effectiveModel}.`;
 
+      log.info({ resolvedClaudePath }, 'Using claude executable path');
       const response = query({
         prompt,
         options: {
           ...queryOptions,
+          // Pass the real claude.exe path so the SDK doesn't fall back to its bundled cli.js
+          // Running `bun <sdk_cli.js>` on Windows causes EPERM errors on C:\Windows\System32\
+          ...(resolvedClaudePath ? { pathToClaudeCodeExecutable: resolvedClaudePath } : {}),
           systemPrompt: { type: 'preset' as const, preset: 'claude_code' as const, append: modelIdentity },
         },
       });
@@ -573,18 +604,33 @@ Your task is INCOMPLETE until:\n1. File exists with valid content\n2. You have R
           // Track subagent workflow (from assistant messages with Task tool)
           // Also track Bash tool_uses to correlate with BGPID results
           if (message.type === 'assistant' && 'message' in message) {
-            const assistantMsg = message as { message: { content: Array<{ type: string; id?: string; name?: string; input?: unknown }> }; parent_tool_use_id: string | null };
+            const assistantMsg = message as unknown as { message: { content: Array<{ type: string; id?: string; name?: string; input?: unknown }> }; parent_tool_use_id: string | null };
             for (const block of assistantMsg.message.content) {
               if (block.type === 'tool_use' && block.name === 'Task' && block.id) {
-                const taskInput = (block as { input?: { subagent_type?: string } }).input;
+                const taskInput = (block as { input?: { subagent_type?: string; team_name?: string; name?: string } }).input;
                 const subagentType = taskInput?.subagent_type || 'unknown';
                 workflowTracker.trackSubagentStart(
                   attemptId,
                   block.id,
                   subagentType,
-                  assistantMsg.parent_tool_use_id
+                  assistantMsg.parent_tool_use_id,
+                  { teamName: taskInput?.team_name, name: taskInput?.name }
                 );
               }
+              // Track TeamCreate tool usage for workflow visualization
+              if (block.type === 'tool_use' && block.name === 'TeamCreate' && block.id) {
+                const teamInput = (block as { input?: { team_name?: string } }).input;
+                if (teamInput?.team_name) {
+                  workflowTracker.trackTeamCreate(attemptId, teamInput.team_name);
+                }
+              }
+              // Track SendMessage tool usage for inter-agent message visualization
+              if (block.type === 'tool_use' && block.name === 'SendMessage' && block.id) {
+                const msgInput = (block as { input?: { type?: string; recipient?: string; content?: string; summary?: string } }).input;
+                if (msgInput) {
+                  workflowTracker.trackMessage(attemptId, msgInput);
+                }
+              }
               // Track Bash tool_uses for BGPID correlation
               if (block.type === 'tool_use' && block.name === 'Bash' && block.id) {
                 const bashInput = block.input as { command?: string } | undefined;
@@ -783,6 +829,13 @@ Your task is INCOMPLETE until:\n1. File exists with valid content\n2. You have R
 
       this.emit('stderr', { attemptId, content: `${errorName}: ${errorMessage}` });
 
+      // Detect "prompt too long" errors for auto-compact handling
+      const isPromptTooLong = errorMessage.toLowerCase().includes('prompt is too long') ||
+                              errorMessage.toLowerCase().includes('request too large');
+      if (isPromptTooLong) {
+        this.emit('promptTooLong', { attemptId });
+      }
+
       // Determine exit code based on error type
       const code = wasAborted ? null : 1;
 
@@ -821,6 +874,7 @@ Your task is INCOMPLETE until:\n1. File exists with valid content\n2. You have R
     pending.resolve({ questions, answers });
     this.pendingQuestions.delete(attemptId);
     this.pendingQuestionData.delete(attemptId);
+    this.emit('questionResolved', { attemptId });
     return true;
   }
 
@@ -839,6 +893,7 @@ Your task is INCOMPLETE until:\n1. File exists with valid content\n2. You have R
     pending.resolve(null);
     this.pendingQuestions.delete(attemptId);
     this.pendingQuestionData.delete(attemptId);
+    this.emit('questionResolved', { attemptId });
     return true;
   }
 
@@ -856,6 +911,16 @@ Your task is INCOMPLETE until:\n1. File exists with valid content\n2. You have R
     return this.pendingQuestionData.get(attemptId) || null;
   }
 
+  /**
+   * Get all pending questions across all running attempts
+   */
+  getAllPendingQuestions(): Array<{ attemptId: string; toolUseId: string; questions: unknown[]; timestamp: number }> {
+    return Array.from(this.pendingQuestionData.entries()).map(([attemptId, data]) => ({
+      attemptId,
+      ...data,
+    }));
+  }
+
   /**
    * Send input to a running agent (legacy method)
    * @deprecated Use answerQuestion() for AskUserQuestion responses
@@ -872,6 +937,27 @@ Your task is INCOMPLETE until:\n1. File exists with valid content\n2. You have R
     return false;
   }
 
+  /**
+   * Compact a conversation by starting a fresh session with context summary
+   * Cannot resume the old session (it's at/near context limit), so we start
+   * fresh and carry forward key context via the prompt.
+   */
+  async compact(options: { attemptId: string; projectPath: string; conversationSummary?: string }): Promise<void> {
+    const { attemptId, projectPath, conversationSummary } = options;
+
+    const compactPrompt = conversationSummary
+      ? `You are continuing a previous conversation that reached the context limit. Here is a summary of the previous context:\n\n${conversationSummary}\n\nPlease acknowledge this context briefly and let the user know you're ready to continue.`
+      : 'A previous conversation reached the context limit. Please let the user know you are ready to continue with a fresh context.';
+
+    // Start a FRESH session — do NOT resume the old session since it's at/near the context limit
+    await this.start({
+      attemptId,
+      projectPath,
+      prompt: compactPrompt,
+      maxTurns: 1,
+    });
+  }
+
   /**
    * Cancel a running agent
    * Uses SDK Query.close() for graceful termination, falls back to AbortController

package/src/lib/db/index.ts

@@ -282,6 +282,24 @@ export function initDb() {
       value TEXT NOT NULL,
       updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
     );
+
+    CREATE TABLE IF NOT EXISTS subagents (
+      id TEXT PRIMARY KEY,
+      attempt_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      name TEXT,
+      parent_id TEXT,
+      team_name TEXT,
+      status TEXT NOT NULL CHECK(status IN ('in_progress', 'completed', 'failed', 'orphaned')),
+      error TEXT,
+      started_at INTEGER,
+      completed_at INTEGER,
+      duration_ms INTEGER,
+      depth INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_subagents_attempt ON subagents(attempt_id);
   `);
 }
 

package/src/lib/db/schema.ts

@@ -275,6 +275,33 @@ export const shells = sqliteTable(
   ]
 );
 
+// Subagents table - workflow agent tracking per attempt
+export const subagents = sqliteTable(
+  'subagents',
+  {
+    id: text('id').primaryKey(), // tool_use_id
+    attemptId: text('attempt_id').notNull(),
+    type: text('type').notNull(), // subagent_type
+    name: text('name'), // agent name
+    parentId: text('parent_id'), // parent tool_use_id
+    teamName: text('team_name'),
+    status: text('status', {
+      enum: ['in_progress', 'completed', 'failed', 'orphaned'],
+    }).notNull(),
+    error: text('error'),
+    startedAt: integer('started_at'),
+    completedAt: integer('completed_at'),
+    durationMs: integer('duration_ms'),
+    depth: integer('depth').notNull().default(0),
+    createdAt: integer('created_at', { mode: 'number' })
+      .notNull()
+      .$defaultFn(() => Date.now()),
+  },
+  (table) => [
+    index('idx_subagents_attempt').on(table.attemptId),
+  ]
+);
+
 // App Settings table - global application settings
 export const appSettings = sqliteTable('app_settings', {
   key: text('key').primaryKey(),
@@ -307,5 +334,7 @@ export type PluginDependencyCache = typeof pluginDependencyCache.$inferSelect;
 export type NewPluginDependencyCache = typeof pluginDependencyCache.$inferInsert;
 export type Shell = typeof shells.$inferSelect;
 export type NewShell = typeof shells.$inferInsert;
+export type Subagent = typeof subagents.$inferSelect;
+export type NewSubagent = typeof subagents.$inferInsert;
 export type AppSetting = typeof appSettings.$inferSelect;
 export type NewAppSetting = typeof appSettings.$inferInsert;

package/src/lib/process-manager.ts

@@ -57,11 +57,18 @@ class ProcessManager extends EventEmitter {
     let claudePath = process.env.CLAUDE_PATH;
 
     if (!claudePath) {
-      const commonPaths = [
-        '/home/roxane/.local/bin/claude',
-        '/usr/local/bin/claude',
-        '/opt/homebrew/bin/claude',
-      ];
+      const isWindows = process.platform === 'win32';
+      const home = process.env.USERPROFILE || process.env.HOME || '';
+      const commonPaths = isWindows
+        ? [
+          `${home}\.local\bin\claude.exe`,
+          `${home}\AppData\Roaming\npm\claude.cmd`,
+        ]
+        : [
+          `/home/${process.env.USER || 'user'}/.local/bin/claude`,
+          '/usr/local/bin/claude',
+          '/opt/homebrew/bin/claude',
+        ];
       claudePath = commonPaths.find(p => existsSync(p));
     }
 
@@ -106,15 +113,29 @@ class ProcessManager extends EventEmitter {
 
     log.info({ claudePath, argsCount: args.length }, 'Spawning process');
 
+    // Normalize path separators for the current OS (fixes mixed slash issues on Windows)
+    const normalizedProjectPath = process.platform === 'win32'
+      ? projectPath.replace(/\//g, '\\')
+      : projectPath;
+
     const child = spawn(claudePath, args, {
-      cwd: projectPath,
+      cwd: normalizedProjectPath,
       stdio: ['ignore', 'pipe', 'pipe'],
       env: {
         ...process.env,
         FORCE_COLOR: '0',
         NO_COLOR: '1',
         TERM: 'dumb',
-        PATH: `${process.env.PATH}:/opt/homebrew/bin:/usr/local/bin`,
+        // On Windows, Bun has a bug where it calls readFile() on each PATH entry
+        // causing EPERM on C:\Windows\System32\ (a protected directory).
+        // Fix: strip Windows system directories from PATH before passing to claude.exe.
+        PATH: process.platform === 'win32'
+          ? (process.env.PATH || '').split(';').filter(p => {
+            const lp = p.toLowerCase().trim().replace(/\//g, '\\');
+            return !lp.startsWith('c:\\windows') &&
+              !lp.startsWith('c:\\program files (x86)\\windows kits');
+          }).join(';')
+          : `${process.env.PATH}:/opt/homebrew/bin:/usr/local/bin`,
       },
     });
 

package/src/lib/session-manager.ts

@@ -310,6 +310,66 @@ export class SessionManager {
 
     return options;
   }
+
+  /**
+   * Extract a conversation summary from a task's attempt logs
+   * Used by compact to carry context into a fresh session
+   * Returns the last assistant message text (most recent context)
+   */
+  async getConversationSummary(taskId: string): Promise<string> {
+    // Get the most recent completed/cancelled attempt
+    const lastAttempt = await db.query.attempts.findFirst({
+      where: and(
+        eq(schema.attempts.taskId, taskId),
+        inArray(schema.attempts.status, ['completed', 'cancelled'])
+      ),
+      orderBy: [desc(schema.attempts.createdAt)],
+    });
+
+    if (!lastAttempt) return '';
+
+    // Get the original prompt from the first attempt for this task
+    const firstAttempt = await db.query.attempts.findFirst({
+      where: eq(schema.attempts.taskId, taskId),
+      orderBy: [schema.attempts.createdAt],
+    });
+    const originalPrompt = firstAttempt?.displayPrompt || firstAttempt?.prompt || '';
+
+    // Get the last assistant message from the most recent attempt
+    const logs = await db.query.attemptLogs.findMany({
+      where: eq(schema.attemptLogs.attemptId, lastAttempt.id),
+    });
+
+    let lastAssistantText = '';
+    for (let i = logs.length - 1; i >= 0; i--) {
+      if (logs[i].type !== 'json') continue;
+      try {
+        const data = JSON.parse(logs[i].content);
+        if (data.type === 'assistant' && data.message?.content) {
+          const text = data.message.content
+            .filter((b: any) => b.type === 'text')
+            .map((b: any) => b.text)
+            .join(' ');
+          if (text.trim()) {
+            lastAssistantText = text.substring(0, 4000);
+            break;
+          }
+        }
+      } catch {
+        // Skip parse errors
+      }
+    }
+
+    let summary = '';
+    if (originalPrompt) {
+      summary += `Original task: ${originalPrompt.substring(0, 500)}\n\n`;
+    }
+    if (lastAssistantText) {
+      summary += `Most recent assistant response:\n${lastAssistantText}`;
+    }
+
+    return summary;
+  }
 }
 
 // Singleton instance

package/src/lib/usage-tracker.ts

@@ -26,11 +26,11 @@ export interface UsageStats {
   durationMs: number;
   durationApiMs: number;
 
-  // Context usage tracking (Active Context Only)
-  contextUsed: number;        // Active context tokens (excludes cache_read)
+  // Context usage tracking (full context window)
+  contextUsed: number;        // Total context tokens (input + cache_read + cache_creation + output)
   contextLimit: number;        // Max context window (200K for Opus/Sonnet)
   contextPercentage: number;   // (contextUsed / contextLimit) * 100
-  baselineContext: number;     // Cached baseline tokens (for reference, not in active count)
+  baselineContext: number;     // First-turn cache_read tokens (for reference)
 
   // Context health metrics (ClaudeKit formulas)
   contextHealth?: ContextHealth;
@@ -142,20 +142,19 @@ class UsageTracker extends EventEmitter {
       stats.totalCacheReadTokens += usage.cache_read_input_tokens || 0;
       stats.totalTokens = stats.totalInputTokens + stats.totalOutputTokens;
 
-      // Calculate ACTIVE context usage (excludes cache_read)
+      // Calculate context usage (all tokens in the context window)
       //
-      // According to Anthropic's Prompt Caching:
-      // - cache_read_input_tokens: Tokens loaded FROM cache (NOT in active window)
-      // - cache_creation_input_tokens: NEW tokens being cached (IN active window)
-      // - input_tokens: New user input (IN active window)
-      // - output_tokens: Model response (IN active window)
+      // Anthropic's Prompt Caching:
+      // - cache_read_input_tokens: Tokens loaded from cache (still occupy context window)
+      // - cache_creation_input_tokens: New tokens being cached (occupy context window)
+      // - input_tokens: New user input (occupy context window)
+      // - output_tokens: Model response (occupy context window)
       //
-      // Active Context Window (200K limit) includes:
+      // Context Window (200K limit) includes ALL of these:
       // - input_tokens: New user message
+      // - cache_read_input_tokens: Cached content (served from cache but still in window)
       // - cache_creation_input_tokens: New cache entries
       // - output_tokens: Current response
-      //
-      // Cache read does NOT count toward 200K limit (stored separately)
       const inputTokens = usage.input_tokens || 0;
       const cacheRead = usage.cache_read_input_tokens || 0;
       const cacheCreation = usage.cache_creation_input_tokens || 0;
@@ -167,17 +166,17 @@ class UsageTracker extends EventEmitter {
         log.info(`First turn baseline (cached): ${cacheRead} tokens`);
       }
 
-      // Active context = NEW tokens only (cache_read NOT included)
-      const activeContext = inputTokens + cacheCreation + outputTokens;
+      // Context = all tokens in the window (cache_read included)
+      const activeContext = inputTokens + cacheRead + cacheCreation + outputTokens;
 
       // Update stats with active context (what's actually in 200K window)
       stats.contextUsed = activeContext;
       stats.contextPercentage = (stats.contextUsed / stats.contextLimit) * 100;
 
-      // Calculate health metrics using active context
+      // Calculate health metrics using full context
       stats.contextHealth = calculateContextHealth(
-        inputTokens + cacheCreation, // active input
-        outputTokens,                 // active output
+        inputTokens + cacheRead + cacheCreation, // total input (including cached)
+        outputTokens,                              // output
         stats.contextLimit
       );
 
@@ -187,10 +186,11 @@ class UsageTracker extends EventEmitter {
         contextPercentage: stats.contextPercentage.toFixed(1),
         healthStatus: stats.contextHealth.status,
         inputTokens,
+        cacheRead,
         cacheCreation,
         outputTokens,
-        cacheRead,
-      }, 'Active context updated');
+        totalInput: inputTokens + cacheRead + cacheCreation,
+      }, 'Context updated (includes cache_read)');
     }
 
     // Aggregate cost (common field)

package/src/lib/workflow-tracker.ts

@@ -1,8 +1,8 @@
 /**
- * Workflow Tracker - Track subagent execution workflow with 2-depth support
+ * Workflow Tracker - Track subagent execution workflow with full tree support
  *
  * Monitors Task tool usage to build real-time workflow visualization:
- * docs-manager → tester → code-reviewer → project-manager (7 done)
+ * Full agent tree with unlimited depth, team tracking, and inter-agent messages.
  */
 
 import { EventEmitter } from 'events';
@@ -14,7 +14,7 @@ const log = createLogger('WorkflowTracker');
 /**
  * Subagent status
  */
-export type SubagentStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+export type SubagentStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'orphaned';
 
 /**
  * Subagent node in workflow tree
@@ -22,14 +22,28 @@ export type SubagentStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
 export interface SubagentNode {
   id: string; // tool_use_id from Task tool
   type: string; // subagent_type
+  name?: string; // agent name (from Task tool input)
   status: SubagentStatus;
   parentId: string | null; // null for top-level
-  depth: number; // 0 for top-level, 1 for nested
+  depth: number; // 0 for top-level, increments with nesting
+  teamName?: string; // team name if part of a team
   startedAt?: number;
   completedAt?: number;
+  durationMs?: number;
   error?: string;
 }
 
+/**
+ * Inter-agent message
+ */
+export interface AgentMessage {
+  fromType: string; // sender agent type or name
+  toType: string; // recipient agent type or name
+  content: string;
+  summary: string;
+  timestamp: number;
+}
+
 /**
  * Workflow state for an attempt
  */
@@ -40,6 +54,18 @@ export interface WorkflowState {
   activeNodes: string[]; // Currently running
   completedNodes: string[]; // Successfully completed
   failedNodes: string[]; // Failed agents
+  messages: AgentMessage[]; // Inter-agent messages
+  teams: string[]; // Team names created in this workflow
+}
+
+/**
+ * Workflow summary for status line and global events
+ */
+export interface WorkflowSummary {
+  chain: string[];
+  completedCount: number;
+  activeCount: number;
+  totalCount: number;
 }
 
 interface WorkflowTrackerEvents {
@@ -70,6 +96,8 @@ class WorkflowTracker extends EventEmitter {
         activeNodes: [],
         completedNodes: [],
         failedNodes: [],
+        messages: [],
+        teams: [],
       };
       this.workflows.set(attemptId, workflow);
     }
@@ -83,29 +111,26 @@ class WorkflowTracker extends EventEmitter {
     attemptId: string,
     toolUseId: string,
     subagentType: string,
-    parentToolUseId: string | null
+    parentToolUseId: string | null,
+    options?: { teamName?: string; name?: string }
   ): void {
     const workflow = this.initWorkflow(attemptId);
 
-    // Determine depth (max 2 depth: 0 for top-level, 1 for nested)
+    // Determine depth - no cap, full tree support
     let depth = 0;
     if (parentToolUseId && workflow.nodes.has(parentToolUseId)) {
       const parent = workflow.nodes.get(parentToolUseId)!;
-      depth = Math.min(parent.depth + 1, 1); // Cap at depth 1
-    }
-
-    // Only track if depth <= 1 (2 levels max)
-    if (depth > 1) {
-      log.info(`Skipping subagent at depth ${depth}: ${subagentType}`);
-      return;
+      depth = parent.depth + 1;
     }
 
     const node: SubagentNode = {
       id: toolUseId,
       type: subagentType,
+      name: options?.name,
       status: 'in_progress',
       parentId: parentToolUseId,
       depth,
+      teamName: options?.teamName,
       startedAt: Date.now(),
     };
 
@@ -141,6 +166,7 @@ class WorkflowTracker extends EventEmitter {
     // Update node status
     node.status = success ? 'completed' : 'failed';
     node.completedAt = Date.now();
+    node.durationMs = node.startedAt ? Date.now() - node.startedAt : undefined;
     if (error) node.error = error;
 
     // Remove from active
@@ -157,6 +183,59 @@ class WorkflowTracker extends EventEmitter {
     this.emit('workflow-update', { attemptId, workflow });
   }
 
+  /**
+   * Track a TeamCreate tool use
+   */
+  trackTeamCreate(attemptId: string, teamName: string): void {
+    const workflow = this.initWorkflow(attemptId);
+    if (!workflow.teams.includes(teamName)) {
+      workflow.teams.push(teamName);
+    }
+    this.emit('workflow-update', { attemptId, workflow });
+  }
+
+  /**
+   * Track a SendMessage tool use
+   */
+  trackMessage(
+    attemptId: string,
+    input: { type?: string; recipient?: string; content?: string; summary?: string }
+  ): void {
+    const workflow = this.initWorkflow(attemptId);
+
+    const message: AgentMessage = {
+      fromType: 'agent', // We don't have sender info from the tool_use block
+      toType: input.recipient || input.type || 'unknown',
+      content: input.content || '',
+      summary: input.summary || '',
+      timestamp: Date.now(),
+    };
+
+    workflow.messages.push(message);
+    this.emit('workflow-update', { attemptId, workflow });
+  }
+
+  /**
+   * Mark all in-progress subagents as orphaned (for disconnect cleanup)
+   */
+  markOrphaned(attemptId: string): SubagentNode[] {
+    const workflow = this.workflows.get(attemptId);
+    if (!workflow) return [];
+
+    const orphaned: SubagentNode[] = [];
+    for (const nodeId of workflow.activeNodes) {
+      const node = workflow.nodes.get(nodeId);
+      if (node) {
+        node.status = 'orphaned';
+        node.completedAt = Date.now();
+        node.durationMs = node.startedAt ? Date.now() - node.startedAt : undefined;
+        orphaned.push(node);
+      }
+    }
+    workflow.activeNodes = [];
+    return orphaned;
+  }
+
   /**
    * Get workflow state for an attempt
    */
@@ -168,12 +247,7 @@ class WorkflowTracker extends EventEmitter {
    * Get workflow summary for status line display
    * Format: "docs-manager → tester → code-reviewer (3 done)"
    */
-  getWorkflowSummary(attemptId: string): {
-    chain: string[];
-    completedCount: number;
-    activeCount: number;
-    totalCount: number;
-  } | null {
+  getWorkflowSummary(attemptId: string): WorkflowSummary | null {
     const workflow = this.workflows.get(attemptId);
     if (!workflow) return null;
 
@@ -182,7 +256,7 @@ class WorkflowTracker extends EventEmitter {
     for (const rootId of workflow.rootNodes) {
       const node = workflow.nodes.get(rootId);
       if (node) {
-        chain.push(node.type);
+        chain.push(node.name || node.type);
       }
     }
 
@@ -194,6 +268,30 @@ class WorkflowTracker extends EventEmitter {
     };
   }
 
+  /**
+   * Get full expanded workflow data for socket emission
+   */
+  getExpandedWorkflow(attemptId: string): {
+    nodes: SubagentNode[];
+    messages: AgentMessage[];
+    summary: WorkflowSummary;
+  } | null {
+    const workflow = this.workflows.get(attemptId);
+    if (!workflow) return null;
+
+    const summary = this.getWorkflowSummary(attemptId);
+    if (!summary) return null;
+
+    return {
+      nodes: Array.from(workflow.nodes.values()).sort((a, b) => {
+        if (a.depth !== b.depth) return a.depth - b.depth;
+        return (a.startedAt || 0) - (b.startedAt || 0);
+      }),
+      messages: workflow.messages,
+      summary,
+    };
+  }
+
   /**
    * Get detailed workflow tree (for debugging/advanced UI)
    */