@townco/agent 0.1.112 → 0.1.113

package/dist/acp-server/adapter.js

@@ -1411,7 +1411,22 @@ export class AgentAcpAdapter {
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "tool_call_update") {
                     const updateMsg = msg;
+                    logger.info("[SUBAGENT] Adapter received tool_call_update", {
+                        sessionId: params.sessionId,
+                        toolCallId: updateMsg.toolCallId,
+                        status: updateMsg.status,
+                        hasMeta: !!updateMsg._meta,
+                        hasSubagentMessages: !!updateMsg._meta?.subagentMessages,
+                        subagentMessageCount: updateMsg._meta?.subagentMessages?.length ||
+                            0,
+                    });
                     const toolCallBlock = contentBlocks.find((block) => block.type === "tool_call" && block.id === updateMsg.toolCallId);
+                    logger.info("[SUBAGENT] Tool call block lookup result", {
+                        sessionId: params.sessionId,
+                        toolCallId: updateMsg.toolCallId,
+                        found: !!toolCallBlock,
+                        blockStatus: toolCallBlock?.status,
+                    });
                     if (toolCallBlock) {
                         if (updateMsg.status) {
                             toolCallBlock.status =
@@ -1444,19 +1459,30 @@ export class AgentAcpAdapter {
                             toolCallBlock.subagentSessionId = meta.subagentSessionId;
                         }
                         if (meta?.subagentMessages) {
-                            logger.info("Storing subagent messages for session replay", {
+                            logger.info("[SUBAGENT] Storing subagent messages for session replay", {
+                                sessionId: params.sessionId,
                                 toolCallId: updateMsg.toolCallId,
                                 messageCount: meta.subagentMessages.length,
+                                contentPreview: meta.subagentMessages[0]?.content?.substring(0, 100),
                             });
                             toolCallBlock.subagentMessages = meta.subagentMessages;
+                            logger.info("[SUBAGENT] Successfully stored messages", {
+                                sessionId: params.sessionId,
+                                toolCallId: updateMsg.toolCallId,
+                                storedCount: toolCallBlock.subagentMessages?.length,
+                            });
                         }
                     }
                     // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
                     if (updateMsg._meta) {
-                        logger.info("Forwarding tool_call_update with _meta to client", {
+                        logger.info("[SUBAGENT] Forwarding tool_call_update with _meta to client", {
+                            sessionId: params.sessionId,
                             toolCallId: updateMsg.toolCallId,
                             status: updateMsg.status,
-                            _meta: updateMsg._meta,
+                            hasSubagentMessages: !!updateMsg._meta
+                                ?.subagentMessages,
+                            subagentMessageCount: updateMsg._meta?.subagentMessages
+                                ?.length || 0,
                         });
                         this.connection.sessionUpdate({
                             sessionId: params.sessionId,
@@ -1467,22 +1493,9 @@ export class AgentAcpAdapter {
                                 _meta: updateMsg._meta,
                             },
                         });
-                    }
-                    // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
-                    if (updateMsg._meta) {
-                        logger.info("Forwarding tool_call_update with _meta to client", {
-                            toolCallId: updateMsg.toolCallId,
-                            status: updateMsg.status,
-                            _meta: updateMsg._meta,
-                        });
-                        this.connection.sessionUpdate({
+                        logger.info("[SUBAGENT] Successfully forwarded to client", {
                             sessionId: params.sessionId,
-                            update: {
-                                sessionUpdate: "tool_call_update",
-                                toolCallId: updateMsg.toolCallId,
-                                status: updateMsg.status,
-                                _meta: updateMsg._meta,
-                            },
+                            toolCallId: updateMsg.toolCallId,
                         });
                     }
                 }

package/dist/acp-server/http.js

@@ -406,6 +406,27 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
         allowMethods: ["GET", "POST", "OPTIONS"],
     }));
     app.get("/health", (c) => c.json({ ok: true }));
+    // Receive browser console logs and write to agent.log
+    const browserLogger = createLogger("gui-console");
+    app.post("/logs/browser", async (c) => {
+        try {
+            const { logs } = await c.req.json();
+            if (Array.isArray(logs)) {
+                for (const log of logs) {
+                    const level = log.level;
+                    const method = browserLogger[level];
+                    if (typeof method === "function") {
+                        method.call(browserLogger, log.message, log.metadata);
+                    }
+                }
+            }
+            return c.json({ ok: true });
+        }
+        catch (error) {
+            logger.error("Failed to process browser logs", { error });
+            return c.json({ ok: false }, 400);
+        }
+    });
     // List available sessions
     app.get("/sessions", async (c) => {
         if (!agentDir || !agentName) {

package/dist/runner/langchain/index.js

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
@@ -11,7 +12,7 @@ import { telemetry } from "../../telemetry/index.js";
 import { calculateContextSize } from "../../utils/context-size-calculator.js";
 import { getModelContextWindow } from "../hooks/constants.js";
 import { isContextOverflowError } from "../hooks/predefined/context-validator.js";
-import { bindGeneratorToAbortSignal, bindGeneratorToEmitUpdate, bindGeneratorToSessionContext, getAbortSignal, runWithAbortSignal, } from "../session-context";
+import { bindGeneratorToAbortSignal, bindGeneratorToEmitUpdate, bindGeneratorToInvocationContext, bindGeneratorToSessionContext, getAbortSignal, getInvocationContext, runWithAbortSignal, } from "../session-context";
 import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
@@ -19,7 +20,7 @@ import { makeBrowserTools } from "./tools/browser";
 import { makeDocumentExtractTool } from "./tools/document_extract";
 import { makeTownE2BTools } from "./tools/e2b";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
-import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
+import { hashQuery, queryToToolCallId, } from "./tools/subagent-connections";
 import { makeTodoWriteTool, TODO_WRITE_TOOL_NAME } from "./tools/todo";
 import { makeTownWebSearchTools, makeWebSearchTools } from "./tools/web_search";
 const _logger = createLogger("agent-runner");
@@ -82,6 +83,14 @@ export class LangchainAgent {
     async *invokeInternal(req) {
         // Start with the base generator
         let generator = this.invokeWithContext(req);
+        // Create invocation-scoped context for subagent event routing
+        // This must be done here so it's available before invokeWithContext starts
+        const subagentInvocationContext = {
+            invocationId: req.sessionId,
+            subagentEventEmitter: new EventEmitter(),
+        };
+        // Bind invocation context first so it's available to all nested operations
+        generator = bindGeneratorToInvocationContext(subagentInvocationContext, generator);
         // Bind abort signal if available (for cancellation support)
         if (req.abortSignal) {
             generator = bindGeneratorToAbortSignal(req.abortSignal, generator);
@@ -108,6 +117,11 @@ export class LangchainAgent {
         return yield* generator;
     }
     async *invokeWithContext(req) {
+        // Get subagent invocation context from AsyncLocalStorage (created in invokeInternal)
+        const subagentInvCtx = getInvocationContext();
+        if (!subagentInvCtx) {
+            throw new Error("No subagent invocation context available - invokeWithContext called outside of invocation binding");
+        }
         // Derive the parent OTEL context for this invocation.
         // If this is a subagent and the parent process propagated an OTEL trace
         // context via sessionMeta.otelTraceContext, use that as the parent;
@@ -140,78 +154,50 @@ export class LangchainAgent {
             // Clear the buffer after flushing
             pendingToolCallNotifications.length = 0;
         }
-        const subagentUpdateQueue = [];
-        let subagentUpdateResolver = null;
         const subagentMessagesQueue = [];
-        // Listen for subagent connection events - resolve any waiting promise immediately
-        const onSubagentConnection = (event) => {
-            _logger.info("Received subagent connection event", {
-                toolCallId: event.toolCallId,
-                port: event.port,
-                sessionId: event.sessionId,
-            });
-            if (subagentUpdateResolver) {
-                // If someone is waiting, resolve immediately
-                const resolver = subagentUpdateResolver;
-                subagentUpdateResolver = null;
-                resolver(event);
-            }
-            else {
-                // Otherwise queue for later
-                subagentUpdateQueue.push(event);
-            }
-        };
-        subagentEvents.on("connection", onSubagentConnection);
-        // Listen for subagent messages events (for session storage)
+        const completedSubagentToolCalls = new Set();
+        const activeSubagentToolCalls = new Set();
+        // Listen for subagent messages events (for live streaming)
+        // Use the invocation-scoped EventEmitter to ensure messages route correctly
         const onSubagentMessages = (event) => {
-            _logger.info("Received subagent messages event", {
+            _logger.info("✓ Received subagent messages event from scoped emitter", {
                 toolCallId: event.toolCallId,
                 messageCount: event.messages.length,
+                completed: event.completed,
+                invocationId: subagentInvCtx.invocationId,
+                sessionId: req.sessionId,
             });
-            subagentMessagesQueue.push(event);
-        };
-        subagentEvents.on("messages", onSubagentMessages);
-        // Helper to get next subagent update (returns immediately if queued, otherwise waits)
-        const waitForSubagentUpdate = () => {
-            if (subagentUpdateQueue.length > 0) {
-                // biome-ignore lint/style/noNonNullAssertion: We check length > 0, so shift() will return a value
-                return Promise.resolve(subagentUpdateQueue.shift());
+            // Track completion
+            if (event.completed) {
+                completedSubagentToolCalls.add(event.toolCallId);
+                _logger.info("✓ Subagent stream completed", {
+                    toolCallId: event.toolCallId,
+                    sessionId: req.sessionId,
+                    totalCompleted: completedSubagentToolCalls.size,
+                });
             }
-            return new Promise((resolve) => {
-                subagentUpdateResolver = resolve;
-            });
+            subagentMessagesQueue.push(event);
         };
-        // Helper to check and yield all pending subagent updates
+        subagentInvCtx.subagentEventEmitter.on("messages", onSubagentMessages);
+        // Helper to check and yield all pending subagent message updates
         async function* yieldPendingSubagentUpdates() {
-            while (subagentUpdateQueue.length > 0) {
-                const update = subagentUpdateQueue.shift();
-                if (!update)
-                    continue;
-                _logger.info("Yielding queued subagent connection update", {
-                    toolCallId: update.toolCallId,
-                    subagentPort: update.port,
-                    subagentSessionId: update.sessionId,
-                });
-                yield {
-                    sessionUpdate: "tool_call_update",
-                    toolCallId: update.toolCallId,
-                    _meta: {
-                        messageId: req.messageId,
-                        subagentPort: update.port,
-                        subagentSessionId: update.sessionId,
-                    },
-                };
-            }
-            // Also yield any pending messages updates
+            _logger.info("[SUBAGENT] yieldPendingSubagentUpdates called", {
+                sessionId: req.sessionId,
+                queueLength: subagentMessagesQueue.length,
+            });
             while (subagentMessagesQueue.length > 0) {
                 const messagesUpdate = subagentMessagesQueue.shift();
                 if (!messagesUpdate)
                     continue;
-                _logger.info("Yielding queued subagent messages update", {
+                _logger.info("[SUBAGENT] Yielding queued subagent messages update", {
+                    sessionId: req.sessionId,
                     toolCallId: messagesUpdate.toolCallId,
                     messageCount: messagesUpdate.messages.length,
+                    contentPreview: messagesUpdate.messages[0]?.content?.substring(0, 100),
+                    hasContentBlocks: (messagesUpdate.messages[0]?.contentBlocks?.length ?? 0) > 0,
+                    toolCallCount: messagesUpdate.messages[0]?.toolCalls?.length ?? 0,
                 });
-                yield {
+                const updateToYield = {
                     sessionUpdate: "tool_call_update",
                     toolCallId: messagesUpdate.toolCallId,
                     _meta: {
@@ -219,6 +205,17 @@ export class LangchainAgent {
                         subagentMessages: messagesUpdate.messages,
                     },
                 };
+                _logger.info("[SUBAGENT] About to yield update object", {
+                    sessionId: req.sessionId,
+                    toolCallId: messagesUpdate.toolCallId,
+                    updateType: updateToYield.sessionUpdate,
+                    hasMetaSubagentMessages: !!updateToYield._meta?.subagentMessages,
+                });
+                yield updateToYield;
+                _logger.info("[SUBAGENT] Successfully yielded update", {
+                    sessionId: req.sessionId,
+                    toolCallId: messagesUpdate.toolCallId,
+                });
             }
         }
         // Add agent.session_id as a base attribute so it propagates to all child spans
@@ -871,53 +868,63 @@ export class LangchainAgent {
                 callbacks: [otelCallbacks],
             }));
             _logger.info("agent.stream created, starting iteration");
-            // Use manual iteration with Promise.race to interleave stream events with subagent updates
-            const streamIterator = (await stream)[Symbol.asyncIterator]();
-            let streamDone = false;
-            let pendingStreamPromise = null;
-            while (!streamDone) {
-                // Get or create the stream promise (reuse if still pending from last iteration)
-                const nextStreamPromise = pendingStreamPromise ?? streamIterator.next();
-                pendingStreamPromise = nextStreamPromise; // Track it
-                // Create subagent wait promise (only if no queued updates)
-                const subagentPromise = waitForSubagentUpdate();
-                // Use Promise.race, but we need to handle both outcomes
-                const result = await Promise.race([
-                    nextStreamPromise.then((r) => ({
-                        type: "stream",
-                        result: r,
-                    })),
-                    subagentPromise.then((u) => ({ type: "subagent", update: u })),
-                ]);
-                if (result.type === "subagent") {
-                    // Got a subagent update - yield it immediately
-                    const update = result.update;
-                    _logger.info("Yielding subagent connection update (via race)", {
-                        toolCallId: update.toolCallId,
-                        subagentPort: update.port,
-                        subagentSessionId: update.sessionId,
+            // Merge the LangChain stream with subagent event stream
+            // This allows both to yield concurrently without polling
+            async function* mergeStreams() {
+                const streamIterator = (await stream)[Symbol.asyncIterator]();
+                const _pending = [];
+                let streamDone = false;
+                let subagentListenerActive = true;
+                // Create a promise that resolves when the next subagent event arrives
+                function createSubagentEventPromise() {
+                    return new Promise((resolve) => {
+                        const handler = (event) => {
+                            subagentInvCtx?.subagentEventEmitter.off("messages", handler);
+                            resolve({ source: "subagent", value: event, done: false });
+                        };
+                        subagentInvCtx?.subagentEventEmitter.once("messages", handler);
                     });
-                    yield {
-                        sessionUpdate: "tool_call_update",
-                        toolCallId: update.toolCallId,
-                        _meta: {
-                            messageId: req.messageId,
-                            subagentPort: update.port,
-                            subagentSessionId: update.sessionId,
-                        },
-                    };
-                    // Continue - the stream promise is still pending, will be reused
-                    continue;
                 }
-                // Got a stream item - clear the pending promise
-                pendingStreamPromise = null;
-                const { done, value: streamItem } = result.result;
-                if (done) {
-                    streamDone = true;
-                    break;
+                // Start listening for subagent events
+                let subagentPromise = createSubagentEventPromise();
+                while (!streamDone || subagentListenerActive) {
+                    // Race between next stream item and next subagent event
+                    const streamPromise = streamIterator.next().then((result) => ({
+                        source: "stream",
+                        value: result.value,
+                        done: result.done ?? false,
+                    }));
+                    const result = await Promise.race([streamPromise, subagentPromise]);
+                    if (result.source === "stream") {
+                        if (result.done) {
+                            streamDone = true;
+                            // Continue to drain remaining subagent events
+                            subagentListenerActive = false;
+                            // Yield any remaining queued messages
+                            while (subagentMessagesQueue.length > 0) {
+                                yield { source: "subagent" };
+                            }
+                            break;
+                        }
+                        yield { source: "stream", value: result.value };
+                    }
+                    else if (result.source === "subagent") {
+                        // Subagent event arrived - it's already in the queue
+                        yield { source: "subagent" };
+                        // Start listening for the next subagent event
+                        subagentPromise = createSubagentEventPromise();
+                    }
                 }
-                // Also yield any queued subagent updates before processing stream item
-                yield* yieldPendingSubagentUpdates();
+            }
+            // Iterate through the merged stream
+            for await (const item of mergeStreams()) {
+                if (item.source === "subagent") {
+                    // Yield any queued subagent messages
+                    yield* yieldPendingSubagentUpdates();
+                    continue;
+                }
+                // Process the stream item
+                const streamItem = item.value;
                 // biome-ignore lint/suspicious/noExplicitAny: LangChain stream items are tuples with dynamic types
                 const [streamMode, chunk] = streamItem;
                 if (streamMode === "updates") {
@@ -1020,10 +1027,19 @@ export class LangchainAgent {
                                     typeof toolCall.args.query === "string") {
                                     const qHash = hashQuery(toolCall.args.query);
                                     queryToToolCallId.set(qHash, toolCall.id);
-                                    telemetry.log("info", "Registered subagent query hash mapping", {
+                                    activeSubagentToolCalls.add(toolCall.id);
+                                    telemetry.log("info", "✓ Registered subagent query hash mapping", {
                                         queryHash: qHash,
                                         toolCallId: toolCall.id,
                                         queryPreview: toolCall.args.query.slice(0, 50),
+                                        timestamp: new Date().toISOString(),
+                                    });
+                                }
+                                else {
+                                    telemetry.log("warn", "✗ Subagent tool call missing query parameter", {
+                                        toolCallId: toolCall.id,
+                                        hasQuery: "query" in (toolCall.args || {}),
+                                        argsKeys: Object.keys(toolCall.args || {}),
                                     });
                                 }
                             }
@@ -1312,15 +1328,62 @@ export class LangchainAgent {
             }
             // Yield any remaining pending subagent connection updates after stream ends
             yield* yieldPendingSubagentUpdates();
+            // Keep polling for subagent messages after stream ends
+            // This ensures we capture messages that arrive after LangChain stream completes
+            _logger.info("[SUBAGENT] Starting post-stream polling for subagent messages", {
+                sessionId: req.sessionId,
+                activeSubagentCount: activeSubagentToolCalls.size,
+            });
+            const checkInterval = 100; // Check every 100ms
+            const maxIdleTime = 5000; // Stop if no messages for 5 seconds (fallback)
+            const maxWaitTime = 300000; // Absolute max 5 minutes
+            const startTime = Date.now();
+            let lastMessageTime = Date.now();
+            while (Date.now() - startTime < maxWaitTime) {
+                // Check if all subagent tool calls have completed
+                if (activeSubagentToolCalls.size > 0 &&
+                    completedSubagentToolCalls.size >= activeSubagentToolCalls.size) {
+                    _logger.info("[SUBAGENT] All subagent tool calls completed", {
+                        sessionId: req.sessionId,
+                        totalSubagents: activeSubagentToolCalls.size,
+                        completedCount: completedSubagentToolCalls.size,
+                    });
+                    break;
+                }
+                // Check if there are pending messages
+                if (subagentMessagesQueue.length > 0) {
+                    _logger.info("[SUBAGENT] Found pending messages, yielding", {
+                        sessionId: req.sessionId,
+                        queueLength: subagentMessagesQueue.length,
+                    });
+                    yield* yieldPendingSubagentUpdates();
+                    lastMessageTime = Date.now();
+                }
+                // Stop if we haven't seen messages for maxIdleTime (fallback for no subagents)
+                if (Date.now() - lastMessageTime > maxIdleTime) {
+                    _logger.info("[SUBAGENT] No new messages for 5 seconds, finishing", {
+                        sessionId: req.sessionId,
+                        hasActiveSubagents: activeSubagentToolCalls.size > 0,
+                    });
+                    break;
+                }
+                // Wait a bit before checking again
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            }
+            if (Date.now() - startTime >= maxWaitTime) {
+                _logger.warn("[SUBAGENT] Timeout waiting for subagents", {
+                    sessionId: req.sessionId,
+                });
+            }
+            // Final yield of any remaining messages
+            yield* yieldPendingSubagentUpdates();
+            _logger.info("[SUBAGENT] Finished post-stream polling", {
+                sessionId: req.sessionId,
+            });
             // Now that content streaming is complete, yield all buffered tool call notifications
             yield* flushPendingToolCalls();
-            // Clean up subagent event listeners
-            subagentEvents.off("connection", onSubagentConnection);
-            subagentEvents.off("messages", onSubagentMessages);
-            // Cancel any pending wait
-            if (subagentUpdateResolver) {
-                subagentUpdateResolver = null;
-            }
+            // Clean up subagent event listener from invocation-scoped emitter
+            subagentInvCtx.subagentEventEmitter.off("messages", onSubagentMessages);
             // Clean up any remaining iteration span
             otelCallbacks?.cleanup();
             // Log successful completion
@@ -1336,9 +1399,8 @@ export class LangchainAgent {
             };
         }
         catch (error) {
-            // Clean up subagent event listeners on error
-            subagentEvents.off("connection", onSubagentConnection);
-            subagentEvents.off("messages", onSubagentMessages);
+            // Clean up subagent event listener on error from invocation-scoped emitter
+            subagentInvCtx.subagentEventEmitter.off("messages", onSubagentMessages);
             // Clean up any remaining iteration span
             otelCallbacks?.cleanup();
             // Check if this is a context overflow error - wrap it for retry handling

package/dist/runner/langchain/tools/subagent-connections.d.ts

@@ -1,12 +1,3 @@
-import { EventEmitter } from "node:events";
-/**
- * Registry for subagent connection info.
- * Maps query hash to connection info so the runner can emit tool_call_update.
- */
-export interface SubagentConnectionInfo {
-    port: number;
-    sessionId: string;
-}
 /**
  * Sub-agent tool call tracked during streaming
  */
@@ -36,14 +27,11 @@ export interface SubagentMessage {
     contentBlocks: SubagentContentBlock[];
     toolCalls: SubagentToolCall[];
 }
-/**
- * Event emitter for subagent connection events.
- * The runner listens to these events and emits tool_call_update.
- */
-export declare const subagentEvents: EventEmitter<[never]>;
 /**
  * Maps query hash to toolCallId.
  * Set by the runner when it sees a subagent tool_call.
+ * This is still global because the registration happens in the parent runner
+ * before subagent execution begins.
  */
 export declare const queryToToolCallId: Map<string, string>;
 /**
@@ -51,12 +39,9 @@ export declare const queryToToolCallId: Map<string, string>;
  */
 export declare function hashQuery(query: string): string;
 /**
- * Called by the subagent tool when connection is established.
- * Emits an event that the runner can listen to.
- */
-export declare function emitSubagentConnection(queryHash: string, connectionInfo: SubagentConnectionInfo): void;
-/**
- * Called by the subagent tool when it completes with accumulated messages.
- * Emits an event with the messages for session storage.
+ * Called by the subagent tool during execution to emit incremental messages.
+ * Emits an event with the messages for live streaming to the UI.
+ * Uses the invocation context's EventEmitter to ensure messages go to the correct parent.
+ * @param completed - If true, signals that the subagent stream has finished
  */
-export declare function emitSubagentMessages(queryHash: string, messages: SubagentMessage[]): void;
+export declare function emitSubagentMessages(queryHash: string, messages: SubagentMessage[], completed?: boolean): void;

package/dist/runner/langchain/tools/subagent-connections.js

@@ -1,22 +1,14 @@
 import { createHash } from "node:crypto";
-import { EventEmitter } from "node:events";
 import { createLogger } from "@townco/core";
+import { getInvocationContext } from "../../session-context.js";
 const logger = createLogger("subagent-connections");
-/**
- * Event emitter for subagent connection events.
- * The runner listens to these events and emits tool_call_update.
- */
-export const subagentEvents = new EventEmitter();
 /**
  * Maps query hash to toolCallId.
  * Set by the runner when it sees a subagent tool_call.
+ * This is still global because the registration happens in the parent runner
+ * before subagent execution begins.
  */
 export const queryToToolCallId = new Map();
-/**
- * Maps query hash to resolved toolCallId (preserved after connection event).
- * Used to correlate messages when the tool completes.
- */
-const queryToResolvedToolCallId = new Map();
 /**
  * Generate a hash from the query string for correlation.
  */
@@ -29,61 +21,45 @@ export function hashQuery(query) {
     return hash;
 }
 /**
- * Called by the subagent tool when connection is established.
- * Emits an event that the runner can listen to.
+ * Called by the subagent tool during execution to emit incremental messages.
+ * Emits an event with the messages for live streaming to the UI.
+ * Uses the invocation context's EventEmitter to ensure messages go to the correct parent.
+ * @param completed - If true, signals that the subagent stream has finished
  */
-export function emitSubagentConnection(queryHash, connectionInfo) {
-    logger.info("emitSubagentConnection called", {
-        queryHash,
-        port: connectionInfo.port,
-        sessionId: connectionInfo.sessionId,
-        registeredHashes: Array.from(queryToToolCallId.keys()),
-    });
+export function emitSubagentMessages(queryHash, messages, completed = false) {
     const toolCallId = queryToToolCallId.get(queryHash);
-    if (toolCallId) {
-        logger.info("Found toolCallId for queryHash, emitting connection event", {
-            queryHash,
-            toolCallId,
-            port: connectionInfo.port,
-            sessionId: connectionInfo.sessionId,
-        });
-        subagentEvents.emit("connection", {
-            toolCallId,
-            ...connectionInfo,
-        });
-        // Preserve the toolCallId for message emission, but remove from pending lookup
-        queryToResolvedToolCallId.set(queryHash, toolCallId);
-        queryToToolCallId.delete(queryHash);
-    }
-    else {
-        logger.warn("No toolCallId found for queryHash", {
+    const invocationCtx = getInvocationContext();
+    if (!invocationCtx) {
+        logger.warn("✗ No invocation context found - cannot emit subagent messages", {
             queryHash,
-            registeredHashes: Array.from(queryToToolCallId.keys()),
+            hasToolCallId: !!toolCallId,
         });
+        return;
     }
-}
-/**
- * Called by the subagent tool when it completes with accumulated messages.
- * Emits an event with the messages for session storage.
- */
-export function emitSubagentMessages(queryHash, messages) {
-    const toolCallId = queryToResolvedToolCallId.get(queryHash);
     if (toolCallId) {
-        logger.info("Emitting subagent messages for storage", {
+        const firstMessage = messages[0];
+        logger.info("✓ Emitting subagent messages for live streaming", {
             queryHash,
             toolCallId,
             messageCount: messages.length,
+            hasContent: firstMessage ? firstMessage.content.length > 0 : false,
+            hasToolCalls: firstMessage ? firstMessage.toolCalls.length > 0 : false,
+            completed,
+            invocationId: invocationCtx.invocationId,
         });
-        subagentEvents.emit("messages", {
+        // Emit to the parent's invocation-scoped EventEmitter
+        invocationCtx.subagentEventEmitter.emit("messages", {
             toolCallId,
             messages,
+            completed,
         });
-        // Clean up the resolved mapping
-        queryToResolvedToolCallId.delete(queryHash);
     }
     else {
-        logger.warn("No resolved toolCallId for messages emission", {
+        logger.warn("✗ No toolCallId found for messages emission (RACE CONDITION)", {
             queryHash,
+            registeredHashes: Array.from(queryToToolCallId.keys()),
+            mapSize: queryToToolCallId.size,
+            invocationId: invocationCtx.invocationId,
         });
     }
 }