feat: live sub-agent log streaming in WebUI

- loop: add ToolEventHandler callback, fires tool_call + tool_result live
- odek: wire ToolEventHandler from Config through to engine
- subagent: add --stream flag, emits NDJSON tool events to stdout
- subagent_tool: read stdout line-by-line, forward via OnSubagentLog
- serve: wire ToolEventHandler to WebSocket, subagent log forwarding
- WebUI: handle subagent_log events, append to running sub-agent cards

Author: jkyberneees

cmd/odek/serve.go

@@ -178,6 +178,34 @@ func newServeAgent(resolved config.ResolvedConfig, system string, sendFn func(v
 	resolved.Dangerous.Approver = approver
 
 	tools := builtinTools(resolved.Dangerous, sm, approver, resolved.MaxConcurrency)
+
+	// Find the delegateTasksTool to wire up sub-agent log streaming
+	var subagentTool *delegateTasksTool
+	for _, t := range tools {
+		if dt, ok := t.(*delegateTasksTool); ok {
+			subagentTool = dt
+			break
+		}
+	}
+	if subagentTool != nil {
+		subagentTool.OnSubagentLog = func(taskIdx int, line string) {
+			var event struct {
+				Type string `json:"type"`
+				Name string `json:"name,omitempty"`
+				Data string `json:"data,omitempty"`
+			}
+			if err := json.Unmarshal([]byte(line), &event); err != nil {
+				return
+			}
+			sendFn(map[string]any{
+				"type":     "subagent_log",
+				"task_idx": taskIdx,
+				"name":     event.Name,
+				"event":    event.Type,
+				"data":     event.Data,
+			})
+		}
+	}
 	var sandboxCleanup func() error
 
 	// MCP server tools
@@ -224,6 +252,13 @@ func newServeAgent(resolved config.ResolvedConfig, system string, sendFn func(v
 		Skills:         &resolved.Skills,
 		SkillManager:   sm,
 		MemoryConfig:   resolved.Memory,
+		ToolEventHandler: func(event, name, data string) {
+			sendFn(map[string]any{
+				"type":  event,
+				"name":  name,
+				"data":  data,
+			})
+		},
 	})
 	if err != nil {
 		return nil, nil, nil, nil, err
@@ -437,26 +472,16 @@ func handlePrompt(
 		newMsgs = newMsgs[origLen:]
 	}
 
-	// Stream the assistant's response
+	// Stream the assistant's response (tool events are streamed live via ToolEventHandler)
 	for _, msg := range newMsgs {
 		if msg.Role == "assistant" {
 			if msg.Content != "" {
 				writeWSJSON(conn, map[string]any{"type": "token", "content": msg.Content})
 			}
-			for _, tc := range msg.ToolCalls {
-				writeWSJSON(conn, map[string]any{
-					"type":    "tool_call",
-					"name":    tc.Function.Name,
-					"command": tc.Function.Arguments,
-				})
-			}
+			// tool_call events are streamed live via ToolEventHandler — skip here
 		}
 		if msg.Role == "tool" {
-			writeWSJSON(conn, map[string]any{
-				"type":   "tool_result",
-				"name":   msg.Name,
-				"output": shorten(msg.Content, 500),
-			})
+			// tool_result events are streamed live via ToolEventHandler — skip here
 		}
 	}
 

cmd/odek/subagent.go

@@ -173,6 +173,7 @@ func subagentCmd(args []string) error {
 		timeout       int
 		maxIter       int
 		quiet         bool
+		stream        bool
 		parentSession string
 	}
 
@@ -207,6 +208,8 @@ func subagentCmd(args []string) error {
 			}
 		case "--quiet":
 			cfg.quiet = true
+		case "--stream":
+			cfg.stream = true
 		case "--parent-session":
 			i++
 			if i < len(args) {
@@ -335,7 +338,8 @@ func subagentCmd(args []string) error {
 	// Create agent — silent renderer for stderr
 	rend := render.New(os.Stderr, !cfg.quiet)
 
-	agent, err := odek.New(odek.Config{
+	// Build agent config, optionally with streaming
+	aCfg := odek.Config{
 		Model:          resolved.Model,
 		BaseURL:        resolved.BaseURL,
 		APIKey:         resolved.APIKey,
@@ -349,7 +353,19 @@ func subagentCmd(args []string) error {
 		Skills:         &resolved.Skills,
 		SkillManager:   sm,
 		MemoryConfig:   resolved.Memory,
-	})
+	}
+	if cfg.stream {
+		aCfg.ToolEventHandler = func(event, name, data string) {
+			line, _ := json.Marshal(map[string]string{
+				"type": event,
+				"name": name,
+				"data": data,
+			})
+			os.Stdout.Write(line)
+			os.Stdout.Write([]byte("\n"))
+		}
+	}
+	agent, err := odek.New(aCfg)
 	if err != nil {
 		return fmt.Errorf("create agent: %w", err)
 	}

cmd/odek/subagent_tool.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bufio"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -24,6 +25,11 @@ type delegateTasksTool struct {
 	maxConcurrency int
 	odekPath       string // path to the odek binary
 	timeout        time.Duration
+
+	// OnSubagentLog, if set, is called with each NDJSON progress line
+	// emitted by a sub-agent. taskIdx is the index within the current
+	// batch. Used by the WebUI for live log streaming.
+	OnSubagentLog func(taskIdx int, line string)
 }
 
 func (t *delegateTasksTool) Name() string { return "delegate_tasks" }
@@ -112,7 +118,7 @@ func (t *delegateTasksTool) Call(args string) (string, error) {
 		sem <- struct{}{}
 		go func(i int, goal, ctx, sys string) {
 			defer func() { <-sem }()
-			r := t.runTask(goal, ctx, sys)
+			r := t.runTask(i, goal, ctx, sys)
 			mu.Lock()
 			results[i] = r
 			mu.Unlock()
@@ -135,7 +141,7 @@ func (t *delegateTasksTool) Call(args string) (string, error) {
 	return buf.String(), nil
 }
 
-func (t *delegateTasksTool) runTask(goal, taskContext, system string) string {
+func (t *delegateTasksTool) runTask(taskIdx int, goal, taskContext, system string) string {
 	ctx, cancel := context.WithTimeout(context.Background(), t.timeout)
 	defer cancel()
 
@@ -163,6 +169,7 @@ func (t *delegateTasksTool) runTask(goal, taskContext, system string) string {
 		"subagent",
 		"--task", taskPath,
 		"--quiet",
+		"--stream",
 	)
 
 	stdout, err := cmd.StdoutPipe()
@@ -178,30 +185,65 @@ func (t *delegateTasksTool) runTask(goal, taskContext, system string) string {
 		return fmt.Sprintf(`{"error":"start: %v"}`, err)
 	}
 
+	// Read stdout line-by-line — NDJSON progress lines followed by final JSON result
 	var result map[string]any
-	if err := json.NewDecoder(stdout).Decode(&result); err != nil {
-		// Wait for process to finish, then check for timeout
-		cmd.Wait()
-		if ctx.Err() != nil {
-			return fmt.Sprintf(`{"error":"timeout after %v"}`, t.timeout)
+	var lastLine string
+	scanner := bufio.NewScanner(stdout)
+	for scanner.Scan() {
+		line := scanner.Text()
+		lastLine = line
+
+		// Check if this is a progress line (NDJSON with "type":"tool_call" or "type":"tool_result")
+		var event struct {
+			Type string `json:"type"`
+		}
+		if err := json.Unmarshal([]byte(line), &event); err == nil {
+			if event.Type == "tool_call" || event.Type == "tool_result" {
+				if t.OnSubagentLog != nil {
+					t.OnSubagentLog(taskIdx, line)
+				}
+				continue
+			}
+		}
+
+		// Not a progress line — parse as result JSON
+		var r map[string]any
+		if err := json.Unmarshal([]byte(line), &r); err == nil {
+			result = r
 		}
-		return fmt.Sprintf(`{"error":"parse result: %v"}`, err)
 	}
+	scannerErr := scanner.Err()
 
 	if err := cmd.Wait(); err != nil {
-		// Process exited with error — result may still be valid JSON
+		// Process exited with error — result may still be valid
 		if result != nil {
 			summary, _ := json.MarshalIndent(result, "", "  ")
 			return string(summary)
 		}
 		if ctx.Err() != nil {
 			return fmt.Sprintf(`{"error":"timeout after %v"}`, t.timeout)
 		}
+		if scannerErr != nil {
+			return fmt.Sprintf(`{"error":"read stdout: %v"}`, scannerErr)
+		}
 		return fmt.Sprintf(`{"error":"exit: %v"}`, err)
 	}
 
-	summary, _ := json.MarshalIndent(result, "", "  ")
-	return string(summary)
+	if result != nil {
+		summary, _ := json.MarshalIndent(result, "", "  ")
+		return string(summary)
+	}
+
+	// Last resort: try parsing the last line as JSON
+	if lastLine != "" {
+		var r map[string]any
+		if err := json.Unmarshal([]byte(lastLine), &r); err == nil {
+			summary, _ := json.MarshalIndent(r, "", "  ")
+			return string(summary)
+		}
+	}
+
+	return fmt.Sprintf(`{"error":"no result from sub-agent"}`)
 }
 
 // Ensure delegateTasksTool implements odek.Tool

cmd/odek/ui/index.html

@@ -393,6 +393,8 @@
 .subagent-card .sa-details.open { display: block; animation: fadeIn 0.2s ease-out; }
 .subagent-card .sa-meta { font-size: 11px; color: var(--text-tertiary); font-family: var(--font-mono); display: flex; gap: 12px; margin-bottom: 6px; }
 .subagent-card .sa-summary { font-size: 12px; color: var(--text-secondary); line-height: 1.5; white-space: pre-wrap; }
+.subagent-card .sa-log { margin-bottom: 6px; }
+.subagent-card .sa-log .log-line { font-size: 11px; color: var(--text-tertiary); font-family: var(--font-mono); line-height: 1.4; padding: 1px 0; }
 .subagent-card .sa-files { display: flex; flex-wrap: wrap; gap: 4px; margin-top: 6px; }
 .subagent-card .sa-files .file-chip { font-size: 11px; padding: 1px 6px; }
 
@@ -1366,17 +1368,21 @@ <h3>Delete session?</h3>
         streamFlush();
         endThinking();
         if (event.name === 'delegate_tasks') {
-          addSubagentGroup(event.command);
+          addSubagentGroup(event.data);
         } else {
-          addToolCall(event.name, event.command);
+          addToolCall(event.name, event.data);
         }
         break;
 
       case 'tool_result':
         if (event.name === 'delegate_tasks' && subagentGroup) {
-          completeSubagents(event.output);
+          completeSubagents(event.data);
         }
-        addToolResult(event.name, event.output);
+        addToolResult(event.name, event.data);
+        break;
+
+      case 'subagent_log':
+        appendSubagentLog(event.task_idx, event);
         break;
 
       case 'done':
@@ -1767,6 +1773,47 @@ <h3>Delete session?</h3>
   el.classList.toggle('open');
 };
 
+function appendSubagentLog(taskIdx, event) {
+  if (!subagentGroup) return;
+  const cards = subagentGroup.querySelectorAll('.subagent-card');
+  const card = cards[taskIdx];
+  if (!card) return;
+
+  // Ensure details are open
+  const details = card.querySelector('.sa-details');
+  if (!details) return;
+  const summaryEl = details.querySelector('.sa-summary');
+
+  // Format the log line
+  let text = '';
+  if (event.event === 'tool_call') {
+    text = '🔧 ' + event.name + (event.data ? '(' + truncateStr(event.data, 60) + ')' : '');
+  } else if (event.event === 'tool_result') {
+    text = '📄 ' + truncateStr(event.data || '', 100);
+  }
+  if (!text) return;
+
+  // Append to existing summary content (or create a log container)
+  let logContainer = card.querySelector('.sa-log');
+  if (!logContainer) {
+    logContainer = document.createElement('div');
+    logContainer.className = 'sa-log';
+    details.insertBefore(logContainer, summaryEl);
+  }
+  const lineEl = document.createElement('div');
+  lineEl.className = 'log-line';
+  lineEl.textContent = text;
+  logContainer.appendChild(lineEl);
+
+  details.classList.add('open');
+  scrollBottom();
+}
+
+function truncateStr(s, n) {
+  if (!s) return '';
+  return s.length > n ? s.substring(0, n) + '…' : s;
+}
+
 // ── Approval ──
 let approvalId = null;
 

internal/loop/loop.go

@@ -18,6 +18,11 @@ import (
 // (formatted skill content) to inject, or empty string if no skills match.
 type SkillLoader func(userInput string) string
 
+// ToolEventHandler is an optional callback invoked for each tool execution
+// during the agent loop — fires before (tool_call) and after (tool_result)
+// each tool invocation. Used by the WebUI for live streaming of tool events.
+type ToolEventHandler func(event string, name string, data string)
+
 // Engine runs the agent loop: observe → think → act → repeat.
 type Engine struct {
 	client      *llm.Client
@@ -29,6 +34,8 @@ type Engine struct {
 	skillLoader SkillLoader // optional: loads matching skills
 	lastSkillMsg string     // last user message that triggered skill loading (dedup)
 
+	toolEventHandler ToolEventHandler // optional: fires during tool execution
+
 	// Token accounting — accumulated across all iterations of the most recent run.
 	// Reset on each Run/RunWithMessages call and read by callers (e.g. WebUI).
 	TotalInputTokens  int
@@ -52,6 +59,9 @@ func New(client *llm.Client, registry *tool.Registry, maxIterations int, systemM
 // SetSkillLoader sets the optional skill loader callback.
 func (e *Engine) SetSkillLoader(sl SkillLoader) { e.skillLoader = sl }
 
+// SetToolEventHandler sets the optional tool event callback for live streaming.
+func (e *Engine) SetToolEventHandler(cb ToolEventHandler) { e.toolEventHandler = cb }
+
 // ── Token Estimation ─────────────────────────────────────────────────
 //
 // Zero-dependency heuristic: 1 token ≈ 4 chars for English text.
@@ -278,6 +288,9 @@ func (e *Engine) runLoop(ctx context.Context, messages []llm.Message) (string, [
 			if e.renderer != nil {
 				e.renderer.ToolCall(tc.Function.Name, tc.Function.Arguments)
 			}
+			if e.toolEventHandler != nil {
+				e.toolEventHandler("tool_call", tc.Function.Name, tc.Function.Arguments)
+			}
 
 			t := e.registry.Get(tc.Function.Name)
 			output := fmt.Sprintf("error: tool %q not found", tc.Function.Name)
@@ -293,6 +306,9 @@ func (e *Engine) runLoop(ctx context.Context, messages []llm.Message) (string, [
 			if e.renderer != nil {
 				e.renderer.ToolResult(output)
 			}
+			if e.toolEventHandler != nil {
+				e.toolEventHandler("tool_result", tc.Function.Name, output)
+			}
 
 			// Wrap tool output in clear delimiters so the model treats
 			// it as DATA, not as instructions. Even if the output