@townco/ui 0.1.110 → 0.1.112

package/dist/core/hooks/use-chat-messages.d.ts

@@ -158,6 +158,12 @@ export declare function useChatMessages(client: AcpClient | null, startSession:
                     };
                 })[] | undefined;
                 isStreaming?: boolean | undefined;
+                _meta?: {
+                    semanticName?: string | undefined;
+                    agentDefinitionName?: string | undefined;
+                    currentActivity?: string | undefined;
+                    statusGenerating?: boolean | undefined;
+                } | undefined;
             }[] | undefined;
             subagentStreaming?: boolean | undefined;
             subagentCompleted?: boolean | undefined;

package/dist/core/hooks/use-subagent-stream.d.ts

@@ -0,0 +1,28 @@
+import type { SubagentMessage } from "../schemas/tool-call.js";
+export interface UseSubagentStreamOptions {
+    /** Sub-agent HTTP port */
+    port: number;
+    /** Sub-agent session ID */
+    sessionId: string;
+    /** Base host (defaults to localhost) */
+    host?: string;
+}
+export interface UseSubagentStreamReturn {
+    /** Accumulated messages from the sub-agent */
+    messages: SubagentMessage[];
+    /** Whether the stream is currently active */
+    isStreaming: boolean;
+    /** Error message if connection failed */
+    error: string | null;
+}
+/**
+ * Hook to connect directly to a sub-agent's SSE endpoint and stream messages.
+ *
+ * This hook:
+ * - Connects to the sub-agent's HTTP server at the given port
+ * - Subscribes to the /events SSE endpoint with the session ID
+ * - Parses incoming session/update notifications
+ * - Extracts text chunks and tool calls
+ * - Returns accumulated messages for display
+ */
+export declare function useSubagentStream(options: UseSubagentStreamOptions | null): UseSubagentStreamReturn;

package/dist/core/hooks/use-subagent-stream.js

@@ -0,0 +1,256 @@
+import { createLogger } from "@townco/core";
+import { useCallback, useEffect, useRef, useState } from "react";
+const logger = createLogger("subagent-stream");
+/**
+ * Hook to connect directly to a sub-agent's SSE endpoint and stream messages.
+ *
+ * This hook:
+ * - Connects to the sub-agent's HTTP server at the given port
+ * - Subscribes to the /events SSE endpoint with the session ID
+ * - Parses incoming session/update notifications
+ * - Extracts text chunks and tool calls
+ * - Returns accumulated messages for display
+ */
+export function useSubagentStream(options) {
+    const [messages, setMessages] = useState([]);
+    // Start as streaming=true if options provided, since we're about to connect
+    const [_isStreaming, setIsStreaming] = useState(!!options);
+    const [hasCompleted, setHasCompleted] = useState(false);
+    const [error, setError] = useState(null);
+    const abortControllerRef = useRef(null);
+    const currentMessageRef = useRef(null);
+    const updateTimeoutRef = useRef(null);
+    // Throttled update to prevent excessive re-renders
+    const scheduleUpdate = useCallback(() => {
+        // If there's already a pending timeout, let it handle the update
+        // (it will read the latest currentMessageRef value)
+        if (updateTimeoutRef.current)
+            return;
+        updateTimeoutRef.current = setTimeout(() => {
+            updateTimeoutRef.current = null;
+            if (currentMessageRef.current) {
+                setMessages([{ ...currentMessageRef.current }]);
+            }
+        }, 250); // Batch updates every 250ms
+    }, []);
+    // Process incoming SSE message from sub-agent
+    // Defined BEFORE connectToSubagent so it's available in the closure
+    const processSSEMessage = useCallback((data) => {
+        try {
+            const message = JSON.parse(data);
+            logger.debug("Processing SSE message", {
+                method: message.method,
+                hasParams: !!message.params,
+            });
+            // Check if this is a session/update notification
+            if (message.method === "session/update" && message.params?.update) {
+                const update = message.params.update;
+                logger.debug("Got session update", {
+                    sessionUpdate: update.sessionUpdate,
+                });
+                if (update.sessionUpdate === "agent_message_chunk") {
+                    // Handle text chunk
+                    const content = update.content;
+                    if (content?.type === "text" && typeof content.text === "string") {
+                        if (currentMessageRef.current) {
+                            currentMessageRef.current.content += content.text;
+                            // Add to contentBlocks - append to last text block or create new one
+                            const blocks = currentMessageRef.current.contentBlocks ?? [];
+                            const lastBlock = blocks[blocks.length - 1];
+                            if (lastBlock && lastBlock.type === "text") {
+                                lastBlock.text += content.text;
+                            }
+                            else {
+                                blocks.push({ type: "text", text: content.text });
+                            }
+                            currentMessageRef.current.contentBlocks = blocks;
+                            scheduleUpdate();
+                        }
+                    }
+                }
+                else if (update.sessionUpdate === "tool_call") {
+                    // Handle new tool call
+                    const toolCall = {
+                        id: update.toolCallId ?? `tc-${Date.now()}`,
+                        title: update.title ?? "Tool call",
+                        prettyName: update._meta?.prettyName,
+                        icon: update._meta?.icon,
+                        status: update.status ?? "pending",
+                        content: [],
+                    };
+                    if (currentMessageRef.current) {
+                        currentMessageRef.current.toolCalls = [
+                            ...(currentMessageRef.current.toolCalls ?? []),
+                            toolCall,
+                        ];
+                        // Add to contentBlocks for interleaved display
+                        const blocks = currentMessageRef.current.contentBlocks ?? [];
+                        blocks.push({ type: "tool_call", toolCall });
+                        currentMessageRef.current.contentBlocks = blocks;
+                        scheduleUpdate();
+                    }
+                }
+                else if (update.sessionUpdate === "tool_call_update") {
+                    // Handle tool call update (status change, completion)
+                    if (currentMessageRef.current?.toolCalls) {
+                        const toolCallId = update.toolCallId;
+                        const updateToolCall = (tc) => tc.id === toolCallId
+                            ? {
+                                ...tc,
+                                status: update.status ?? tc.status,
+                                content: update.content ?? tc.content,
+                            }
+                            : tc;
+                        currentMessageRef.current.toolCalls =
+                            currentMessageRef.current.toolCalls.map(updateToolCall);
+                        // Also update in contentBlocks
+                        if (currentMessageRef.current.contentBlocks) {
+                            currentMessageRef.current.contentBlocks =
+                                currentMessageRef.current.contentBlocks.map((block) => block.type === "tool_call"
+                                    ? { ...block, toolCall: updateToolCall(block.toolCall) }
+                                    : block);
+                        }
+                        scheduleUpdate();
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger.error("Failed to parse sub-agent SSE message", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }, [scheduleUpdate]);
+    const connectToSubagent = useCallback(async (port, sessionId, host, protocol) => {
+        const baseUrl = `${protocol}//${host}:${port}`;
+        logger.info("Connecting to sub-agent SSE", { baseUrl, sessionId });
+        setIsStreaming(true);
+        setError(null);
+        // Create abort controller for cleanup
+        const abortController = new AbortController();
+        abortControllerRef.current = abortController;
+        try {
+            logger.info("Fetching SSE endpoint", {
+                url: `${baseUrl}/events`,
+                sessionId,
+            });
+            const response = await fetch(`${baseUrl}/events`, {
+                method: "GET",
+                headers: {
+                    "X-Session-ID": sessionId,
+                },
+                signal: abortController.signal,
+            });
+            logger.info("SSE response received", {
+                status: response.status,
+                ok: response.ok,
+            });
+            if (!response.ok) {
+                throw new Error(`SSE connection failed: HTTP ${response.status}`);
+            }
+            if (!response.body) {
+                throw new Error("Response body is null");
+            }
+            logger.info("Sub-agent SSE connection opened, starting to read stream");
+            // Read the SSE stream
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            // Initialize current message
+            currentMessageRef.current = {
+                id: `subagent-${Date.now()}`,
+                content: "",
+                toolCalls: [],
+                contentBlocks: [],
+                isStreaming: true,
+            };
+            setMessages([currentMessageRef.current]);
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    logger.debug("Sub-agent SSE stream closed");
+                    break;
+                }
+                // Decode the chunk and add to buffer
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete SSE messages
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || ""; // Keep incomplete line in buffer
+                let currentEvent = { event: "message", data: "" };
+                for (const line of lines) {
+                    if (line.startsWith("event:")) {
+                        currentEvent.event = line.substring(6).trim();
+                    }
+                    else if (line.startsWith("data:")) {
+                        currentEvent.data = line.substring(5).trim();
+                    }
+                    else if (line === "") {
+                        // Empty line signals end of event
+                        if (currentEvent.event === "message" && currentEvent.data) {
+                            processSSEMessage(currentEvent.data);
+                        }
+                        // Reset for next event
+                        currentEvent = { event: "message", data: "" };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                logger.debug("Sub-agent SSE stream aborted");
+            }
+            else {
+                const errorMessage = err instanceof Error
+                    ? err.message
+                    : "Failed to connect to sub-agent";
+                logger.error("Sub-agent SSE error", { error: errorMessage });
+                setError(errorMessage);
+            }
+        }
+        finally {
+            // Mark streaming as complete
+            if (currentMessageRef.current) {
+                currentMessageRef.current.isStreaming = false;
+                setMessages((prev) => prev.map((m) => m.id === currentMessageRef.current?.id
+                    ? { ...m, isStreaming: false }
+                    : m));
+            }
+            setHasCompleted(true);
+            setIsStreaming(false);
+            abortControllerRef.current = null;
+            logger.debug("Sub-agent stream completed");
+        }
+    }, [processSSEMessage]);
+    // Extract values from options (memoized to avoid dependency issues)
+    const port = options?.port;
+    const sessionId = options?.sessionId;
+    const host = options?.host ??
+        (typeof window !== "undefined" ? window.location.hostname : "localhost");
+    const protocol = typeof window !== "undefined" ? window.location.protocol : "http:";
+    // Connect when options change
+    useEffect(() => {
+        if (!port || !sessionId) {
+            return;
+        }
+        // Reset state for new connection
+        setMessages([]);
+        setError(null);
+        setHasCompleted(false);
+        setIsStreaming(true);
+        connectToSubagent(port, sessionId, host, protocol);
+        // Cleanup on unmount or options change
+        return () => {
+            if (abortControllerRef.current) {
+                abortControllerRef.current.abort();
+                abortControllerRef.current = null;
+            }
+            if (updateTimeoutRef.current) {
+                clearTimeout(updateTimeoutRef.current);
+                updateTimeoutRef.current = null;
+            }
+        };
+    }, [port, sessionId, host, protocol, connectToSubagent]);
+    // Derive streaming status: streaming if we haven't completed yet
+    const effectiveIsStreaming = !hasCompleted;
+    return { messages, isStreaming: effectiveIsStreaming, error };
+}

package/dist/core/hooks/use-tool-calls.d.ts

@@ -155,6 +155,12 @@ export declare function useToolCalls(client: AcpClient | null): {
                 };
             })[] | undefined;
             isStreaming?: boolean | undefined;
+            _meta?: {
+                semanticName?: string | undefined;
+                agentDefinitionName?: string | undefined;
+                currentActivity?: string | undefined;
+                statusGenerating?: boolean | undefined;
+            } | undefined;
         }[] | undefined;
         subagentStreaming?: boolean | undefined;
         subagentCompleted?: boolean | undefined;
@@ -306,6 +312,12 @@ export declare function useToolCalls(client: AcpClient | null): {
                 };
             })[] | undefined;
             isStreaming?: boolean | undefined;
+            _meta?: {
+                semanticName?: string | undefined;
+                agentDefinitionName?: string | undefined;
+                currentActivity?: string | undefined;
+                statusGenerating?: boolean | undefined;
+            } | undefined;
         }[] | undefined;
         subagentStreaming?: boolean | undefined;
         subagentCompleted?: boolean | undefined;

package/dist/core/schemas/chat.d.ts

@@ -237,6 +237,12 @@ export declare const DisplayMessage: z.ZodObject<{
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">>>;
             isStreaming: z.ZodOptional<z.ZodBoolean>;
+            _meta: z.ZodOptional<z.ZodObject<{
+                semanticName: z.ZodOptional<z.ZodString>;
+                agentDefinitionName: z.ZodOptional<z.ZodString>;
+                currentActivity: z.ZodOptional<z.ZodString>;
+                statusGenerating: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         subagentStreaming: z.ZodOptional<z.ZodBoolean>;
         subagentCompleted: z.ZodOptional<z.ZodBoolean>;
@@ -502,6 +508,12 @@ export declare const ChatSessionState: z.ZodObject<{
                     }, z.core.$strip>;
                 }, z.core.$strip>], "type">>>;
                 isStreaming: z.ZodOptional<z.ZodBoolean>;
+                _meta: z.ZodOptional<z.ZodObject<{
+                    semanticName: z.ZodOptional<z.ZodString>;
+                    agentDefinitionName: z.ZodOptional<z.ZodString>;
+                    currentActivity: z.ZodOptional<z.ZodString>;
+                    statusGenerating: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>>;
             subagentStreaming: z.ZodOptional<z.ZodBoolean>;
             subagentCompleted: z.ZodOptional<z.ZodBoolean>;

package/dist/core/schemas/tool-call.d.ts

@@ -262,6 +262,12 @@ export declare const SubagentMessageSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>], "type">>>;
     isStreaming: z.ZodOptional<z.ZodBoolean>;
+    _meta: z.ZodOptional<z.ZodObject<{
+        semanticName: z.ZodOptional<z.ZodString>;
+        agentDefinitionName: z.ZodOptional<z.ZodString>;
+        currentActivity: z.ZodOptional<z.ZodString>;
+        statusGenerating: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SubagentMessage = z.infer<typeof SubagentMessageSchema>;
 /**
@@ -443,6 +449,12 @@ export declare const ToolCallSchema: z.ZodObject<{
             }, z.core.$strip>;
         }, z.core.$strip>], "type">>>;
         isStreaming: z.ZodOptional<z.ZodBoolean>;
+        _meta: z.ZodOptional<z.ZodObject<{
+            semanticName: z.ZodOptional<z.ZodString>;
+            agentDefinitionName: z.ZodOptional<z.ZodString>;
+            currentActivity: z.ZodOptional<z.ZodString>;
+            statusGenerating: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     subagentStreaming: z.ZodOptional<z.ZodBoolean>;
     subagentCompleted: z.ZodOptional<z.ZodBoolean>;
@@ -596,6 +608,12 @@ export declare const ToolCallUpdateSchema: z.ZodObject<{
             }, z.core.$strip>;
         }, z.core.$strip>], "type">>>;
         isStreaming: z.ZodOptional<z.ZodBoolean>;
+        _meta: z.ZodOptional<z.ZodObject<{
+            semanticName: z.ZodOptional<z.ZodString>;
+            agentDefinitionName: z.ZodOptional<z.ZodString>;
+            currentActivity: z.ZodOptional<z.ZodString>;
+            statusGenerating: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     subagentCompleted: z.ZodOptional<z.ZodBoolean>;
     _meta: z.ZodOptional<z.ZodObject<{

package/dist/core/schemas/tool-call.js

@@ -117,6 +117,14 @@ export const SubagentMessageSchema = z.object({
     /** Interleaved content blocks in arrival order */
     contentBlocks: z.array(SubagentContentBlockSchema).optional(),
     isStreaming: z.boolean().optional(),
+    _meta: z
+        .object({
+        semanticName: z.string().optional(),
+        agentDefinitionName: z.string().optional(),
+        currentActivity: z.string().optional(),
+        statusGenerating: z.boolean().optional(),
+    })
+        .optional(),
 });
 /**
  * Complete tool call state as displayed in the UI

package/dist/gui/components/InvokingGroup.d.ts

@@ -0,0 +1,9 @@
+import type { ToolCall as ToolCallType } from "../../core/schemas/tool-call.js";
+export interface InvokingGroupProps {
+    toolCalls: ToolCallType[];
+}
+/**
+ * InvokingGroup component - displays a group of preliminary (invoking) tool calls
+ * Shows as "Invoking parallel operation (N)" with a summary of unique tool names
+ */
+export declare function InvokingGroup({ toolCalls }: InvokingGroupProps): import("react/jsx-runtime").JSX.Element;

package/dist/gui/components/InvokingGroup.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ListVideo } from "lucide-react";
+import React from "react";
+/**
+ * InvokingGroup component - displays a group of preliminary (invoking) tool calls
+ * Shows as "Invoking parallel operation (N)" with a summary of unique tool names
+ */
+export function InvokingGroup({ toolCalls }) {
+    // Get unique display names for the summary
+    const displayNames = toolCalls.map((tc) => tc.prettyName || tc.title);
+    const uniqueNames = [...new Set(displayNames)];
+    const summary = uniqueNames.length <= 2
+        ? uniqueNames.join(", ")
+        : `${uniqueNames.slice(0, 2).join(", ")} +${uniqueNames.length - 2} more`;
+    return (_jsxs("div", { className: "flex flex-col my-4", children: [_jsxs("div", { className: "flex items-center gap-1.5 text-paragraph-sm text-muted-foreground/50", children: [_jsx(ListVideo, { className: "h-3 w-3" }), _jsx("span", { children: "Invoking parallel operation" }), _jsx("span", { className: "text-[10px] bg-muted px-1.5 py-0.5 rounded text-muted-foreground/50", children: toolCalls.length })] }), _jsx("span", { className: "text-paragraph-sm text-muted-foreground/50 pl-4.5", children: summary })] }));
+}

package/dist/gui/components/SubAgentDetails.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ChevronDown, Loader2 } from "lucide-react";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { MarkdownRenderer } from "./MarkdownRenderer.js";
@@ -93,10 +93,13 @@ export function SubAgentDetails({ parentStatus, agentName, query, isExpanded: co
         ? (query.split("\n")[0] ?? "").slice(0, 100) +
             (query.length > 100 ? "..." : "")
         : "";
-    return (_jsxs("div", { children: [!isExpanded && (_jsx("div", { className: "w-full max-w-md", children: previewText ? (_jsx("p", { className: "text-paragraph-sm text-muted-foreground/70 truncate", children: previewText })) : queryFirstLine ? (_jsx("p", { className: "text-paragraph-sm text-muted-foreground/50 truncate", children: queryFirstLine })) : null })), isExpanded && (_jsxs("div", { className: "space-y-3", children: [(agentName || query) && (_jsxs("div", { children: [
+    return (_jsxs("div", { children: [!isExpanded && (_jsx("div", { className: "w-full max-w-md", children: currentMessage?._meta?.currentActivity ? (_jsx("p", { className: "text-paragraph-sm text-muted-foreground/70 truncate", children: currentMessage._meta.currentActivity })) : currentMessage?._meta?.statusGenerating ? (_jsx("p", { className: "text-paragraph-sm text-muted-foreground/50 truncate animate-pulse", children: "Determining status..." })) : previewText ? (_jsx("p", { className: "text-paragraph-sm text-muted-foreground/70 truncate", children: previewText })) : queryFirstLine ? (_jsx("p", { className: "text-paragraph-sm text-muted-foreground/50 truncate", children: queryFirstLine })) : null })), isExpanded && (_jsxs("div", { className: "space-y-3", children: [(agentName || query) && (_jsxs("div", { children: [
                             _jsx("div", { className: "text-[10px] font-bold text-muted-foreground uppercase tracking-wider mb-1.5 font-sans", children: "Input" }), _jsxs("div", { className: "text-[11px] font-mono space-y-1", children: [agentName && (_jsxs("div", { children: [
-                                            _jsx("span", { className: "text-muted-foreground", children: "agentName: " }), _jsx("span", { className: "text-foreground", children: agentName })
-                                        ] })), query && (_jsxs("div", { children: [
+                                            _jsx("span", { className: "text-muted-foreground", children: storedMessages?.[0]?._meta?.semanticName
+                                                    ? "Task: "
+                                                    : "agentName: " }), storedMessages?.[0]?._meta?.semanticName ? (_jsxs(_Fragment, { children: [
+                                                    _jsx("span", { className: "text-foreground font-medium", children: storedMessages[0]._meta.semanticName }), _jsxs("span", { className: "text-muted-foreground text-[10px] ml-1", children: ["(", agentName, ")"] })
+                                                ] })) : (_jsx("span", { className: "text-foreground", children: agentName }))] })), query && (_jsxs("div", { children: [
                                             _jsx("span", { className: "text-muted-foreground", children: "query: " }), _jsx("span", { className: "text-foreground", children: query })
                                         ] }))] })
                         ] })), _jsxs("div", { children: [

package/dist/gui/components/ToolCall.d.ts

@@ -0,0 +1,8 @@
+import type { ToolCall as ToolCallType } from "../../core/schemas/tool-call.js";
+export interface ToolCallProps {
+    toolCall: ToolCallType;
+}
+/**
+ * ToolCall component - displays a single tool call with collapsible details
+ */
+export declare function ToolCall({ toolCall }: ToolCallProps): import("react/jsx-runtime").JSX.Element;

package/dist/gui/components/ToolCall.js

@@ -0,0 +1,226 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import JsonView from "@uiw/react-json-view";
+import { AlertCircle, CheckSquare, ChevronDown, ChevronRight, CircleDot, Cloud, Edit, FileText, Globe, Image, Link, Search, Wrench, } from "lucide-react";
+import React, { useState } from "react";
+import { ChatLayout } from "./index.js";
+import { SubAgentDetails } from "./SubAgentDetails.js";
+import { useTheme } from "./ThemeProvider.js";
+/**
+ * Map of icon names to Lucide components
+ */
+const ICON_MAP = {
+    Globe: Globe,
+    Image: Image,
+    Link: Link,
+    Cloud: Cloud,
+    CheckSquare: CheckSquare,
+    Search: Search,
+    FileText: FileText,
+    Edit: Edit,
+    Wrench: Wrench,
+    CircleDot: CircleDot,
+};
+/**
+ * Tool call kind icons (using emoji for simplicity)
+ */
+const _kindIcons = {
+    read: "\u{1F4C4}",
+    edit: "\u{270F}\u{FE0F}",
+    delete: "\u{1F5D1}\u{FE0F}",
+    move: "\u{1F4E6}",
+    search: "\u{1F50D}",
+    execute: "\u{2699}\u{FE0F}",
+    think: "\u{1F4AD}",
+    fetch: "\u{1F310}",
+    switch_mode: "\u{1F501}",
+    other: "\u{1F527}",
+};
+/**
+ * ToolCall component - displays a single tool call with collapsible details
+ */
+export function ToolCall({ toolCall }) {
+    const [isExpanded, setIsExpanded] = useState(false);
+    const [isSubagentExpanded, setIsSubagentExpanded] = useState(false);
+    const { resolvedTheme } = useTheme();
+    // Detect TodoWrite tool and subagent
+    const isTodoWrite = toolCall.title === "todo_write";
+    const isSubagentCall = !!(toolCall.subagentPort && toolCall.subagentSessionId);
+    // Safely access ChatLayout context - will be undefined if not within ChatLayout
+    const layoutContext = React.useContext(ChatLayout.Context);
+    // Click handler: toggle sidepanel for TodoWrite, subagent details for subagents, expand for others
+    const handleHeaderClick = React.useCallback(() => {
+        if (isTodoWrite && layoutContext) {
+            // Toggle sidepanel - close if already open on todo tab, otherwise open
+            if (layoutContext.panelSize !== "hidden" &&
+                layoutContext.activeTab === "todo") {
+                layoutContext.setPanelSize("hidden");
+            }
+            else {
+                layoutContext.setPanelSize("small");
+                layoutContext.setActiveTab("todo");
+            }
+        }
+        else if (isSubagentCall) {
+            // Toggle subagent details
+            setIsSubagentExpanded(!isSubagentExpanded);
+        }
+        else {
+            // Normal expand/collapse
+            setIsExpanded(!isExpanded);
+        }
+    }, [
+        isTodoWrite,
+        layoutContext,
+        isExpanded,
+        isSubagentCall,
+        isSubagentExpanded,
+    ]);
+    // Determine which icon to show
+    const IconComponent = toolCall.icon && ICON_MAP[toolCall.icon]
+        ? ICON_MAP[toolCall.icon]
+        : CircleDot;
+    // Determine display name
+    const displayName = toolCall.prettyName || toolCall.title;
+    // Determine icon color based on status (especially for subagents)
+    const isSubagentRunning = isSubagentCall &&
+        (toolCall.status === "in_progress" || toolCall.status === "pending");
+    const isSubagentFailed = isSubagentCall && toolCall.status === "failed";
+    const iconColorClass = isSubagentCall
+        ? isSubagentFailed
+            ? "text-destructive"
+            : isSubagentRunning
+                ? "text-foreground animate-pulse"
+                : "text-green-500"
+        : "text-muted-foreground";
+    const statusTooltip = isSubagentCall
+        ? isSubagentFailed
+            ? "Sub-agent failed"
+            : isSubagentRunning
+                ? "Sub-agent running"
+                : "Sub-agent completed"
+        : undefined;
+    // Check if there's an error
+    const hasError = toolCall.status === "failed" || !!toolCall.error;
+    // Check if this is a preliminary (pending) tool call without full details yet
+    const isPreliminary = toolCall.status === "pending" &&
+        (!toolCall.rawInput || Object.keys(toolCall.rawInput).length === 0);
+    // JSON View style based on theme
+    const jsonStyle = {
+        fontSize: "11px",
+        backgroundColor: "transparent",
+        fontFamily: "inherit",
+        "--w-rjv-color": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
+        "--w-rjv-key-string": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
+        "--w-rjv-background-color": "transparent",
+        "--w-rjv-line-color": resolvedTheme === "dark" ? "#27272a" : "#e4e4e7",
+        "--w-rjv-arrow-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
+        "--w-rjv-edit-color": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
+        "--w-rjv-info-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
+        "--w-rjv-update-color": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
+        "--w-rjv-copied-color": resolvedTheme === "dark" ? "#fafafa" : "#09090b",
+        "--w-rjv-copied-success-color": resolvedTheme === "dark" ? "#22c55e" : "#16a34a",
+        "--w-rjv-curlybraces-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
+        "--w-rjv-colon-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
+        "--w-rjv-brackets-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
+        "--w-rjv-quotes-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
+        "--w-rjv-quotes-string-color": resolvedTheme === "dark" ? "#a1a1aa" : "#71717a",
+        "--w-rjv-type-string-color": resolvedTheme === "dark" ? "#22c55e" : "#16a34a",
+        "--w-rjv-type-int-color": resolvedTheme === "dark" ? "#f59e0b" : "#d97706",
+        "--w-rjv-type-float-color": resolvedTheme === "dark" ? "#f59e0b" : "#d97706",
+        "--w-rjv-type-bigint-color": resolvedTheme === "dark" ? "#f59e0b" : "#d97706",
+        "--w-rjv-type-boolean-color": resolvedTheme === "dark" ? "#3b82f6" : "#2563eb",
+        "--w-rjv-type-date-color": resolvedTheme === "dark" ? "#ec4899" : "#db2777",
+        "--w-rjv-type-url-color": resolvedTheme === "dark" ? "#3b82f6" : "#2563eb",
+        "--w-rjv-type-null-color": resolvedTheme === "dark" ? "#ef4444" : "#dc2626",
+        "--w-rjv-type-nan-color": resolvedTheme === "dark" ? "#ef4444" : "#dc2626",
+        "--w-rjv-type-undefined-color": resolvedTheme === "dark" ? "#ef4444" : "#dc2626",
+    };
+    // Preliminary tool calls show as simple light gray text without expansion
+    if (isPreliminary) {
+        return (_jsx("div", { className: "flex flex-col my-4", children: _jsxs("span", { className: "text-paragraph-sm text-muted-foreground/50", children: ["Invoking ", displayName] }) }));
+    }
+    return (_jsxs("div", { className: "flex flex-col my-4", children: [_jsxs("button", { type: "button", className: "flex flex-col items-start gap-0.5 cursor-pointer bg-transparent border-none p-0 text-left group w-fit", onClick: handleHeaderClick, "aria-expanded": isTodoWrite ? undefined : isExpanded, children: [_jsxs("div", { className: "flex items-center gap-1.5 text-[11px] font-medium text-muted-foreground", children: [_jsx("div", { className: iconColorClass, title: statusTooltip, children: _jsx(IconComponent, { className: "h-3 w-3" }) }), _jsx("span", { className: "text-paragraph-sm text-muted-foreground", children: displayName }), hasError && _jsx(AlertCircle, { className: "h-3 w-3 text-destructive" }), isTodoWrite ? (_jsx(ChevronRight, { className: "h-3 w-3 text-muted-foreground/70" })) : (_jsx(ChevronDown, { className: `h-3 w-3 text-muted-foreground/70 transition-transform duration-200 ${isExpanded ? "rotate-180" : ""}` }))] }), toolCall.subline && (_jsx("span", { className: "text-paragraph-sm text-muted-foreground/70 pl-4.5", children: toolCall.subline }))] }), !isTodoWrite && isSubagentCall && (_jsx("div", { className: "pl-4.5", children: _jsx(SubAgentDetails, { port: toolCall.subagentPort, sessionId: toolCall.subagentSessionId, parentStatus: toolCall.status, agentName: toolCall.rawInput?.agentName, query: toolCall.rawInput?.query, isExpanded: isSubagentExpanded, onExpandChange: setIsSubagentExpanded }) })), !isTodoWrite && !isSubagentCall && isExpanded && (_jsxs("div", { className: "mt-2 text-sm border border-border rounded-lg bg-card overflow-hidden w-full", children: [toolCall.rawInput &&
+                        Object.keys(toolCall.rawInput).length > 0 &&
+                        !toolCall.subagentPort && (_jsxs("div", { className: "p-3 border-b border-border", children: [_jsx("div", { className: "text-[10px] font-bold text-muted-foreground uppercase tracking-wider mb-1.5 font-sans", children: "Input" }), _jsx("div", { className: "text-[11px] font-mono text-foreground", children: _jsx(JsonView, { value: toolCall.rawInput, collapsed: false, displayDataTypes: false, displayObjectSize: false, enableClipboard: true, style: jsonStyle }) })] })), toolCall.locations && toolCall.locations.length > 0 && (_jsxs("div", { className: "p-3 border-b border-border", children: [_jsx("div", { className: "text-[10px] font-bold text-muted-foreground uppercase tracking-wider mb-1.5 font-sans", children: "Files" }), _jsx("ul", { className: "space-y-1", children: toolCall.locations.map((loc) => (_jsxs("li", { className: "font-mono text-[11px] text-foreground bg-muted px-1.5 py-0.5 rounded w-fit", children: [loc.path, loc.line !== null &&
+                                            loc.line !== undefined &&
+                                            `:${loc.line}`] }, `${loc.path}:${loc.line ?? ""}`))) })] })), (toolCall.content && toolCall.content.length > 0) ||
+                        toolCall.error ? (_jsxs("div", { className: "p-3 border-b border-border last:border-0", children: [_jsx("div", { className: "text-[10px] font-bold text-muted-foreground uppercase tracking-wider mb-1.5 font-sans", children: "Output" }), _jsxs("div", { className: "space-y-2 text-[11px] text-foreground", children: [toolCall.content?.map((block, idx) => {
+                                        // Generate a stable key based on content
+                                        const getBlockKey = () => {
+                                            if (block.type === "diff" && "path" in block) {
+                                                return `diff-${block.path}-${idx}`;
+                                            }
+                                            if (block.type === "terminal" && "terminalId" in block) {
+                                                return `terminal-${block.terminalId}`;
+                                            }
+                                            if (block.type === "text" && "text" in block) {
+                                                return `text-${block.text.substring(0, 20)}-${idx}`;
+                                            }
+                                            if (block.type === "content" && "content" in block) {
+                                                const innerContent = block.content;
+                                                return `content-${innerContent.text?.substring(0, 20)}-${idx}`;
+                                            }
+                                            return `block-${idx}`;
+                                        };
+                                        // Helper to render text content (with JSON parsing if applicable)
+                                        const renderTextContent = (text, key) => {
+                                            // Try to parse as JSON
+                                            try {
+                                                const parsed = JSON.parse(text);
+                                                // If it's an object or array, render with JsonView
+                                                if (typeof parsed === "object" && parsed !== null) {
+                                                    return (_jsx("div", { className: "text-[11px]", children: _jsx(JsonView, { value: parsed, collapsed: false, displayDataTypes: false, displayObjectSize: false, enableClipboard: true, style: jsonStyle }) }, key));
+                                                }
+                                            }
+                                            catch {
+                                                // Not valid JSON, render as plain text
+                                            }
+                                            // Render as plain text
+                                            return (_jsx("pre", { className: "whitespace-pre-wrap font-mono text-[11px] text-foreground overflow-x-auto", children: text }, key));
+                                        };
+                                        // Handle nested content blocks (ACP format)
+                                        if (block.type === "content" && "content" in block) {
+                                            const innerContent = block.content;
+                                            if (innerContent.type === "text" && innerContent.text) {
+                                                return renderTextContent(innerContent.text, getBlockKey());
+                                            }
+                                        }
+                                        // Handle direct text blocks
+                                        if (block.type === "text" && "text" in block) {
+                                            return renderTextContent(block.text, getBlockKey());
+                                        }
+                                        // Handle image blocks
+                                        if (block.type === "image") {
+                                            const alt = block.alt || "Generated image";
+                                            let imageSrc;
+                                            if ("data" in block) {
+                                                // Base64 encoded image
+                                                const mimeType = block.mimeType || "image/png";
+                                                imageSrc = `data:${mimeType};base64,${block.data}`;
+                                            }
+                                            else if ("url" in block) {
+                                                // URL or file path
+                                                imageSrc = block.url;
+                                            }
+                                            else {
+                                                return null;
+                                            }
+                                            return (_jsx("div", { className: "my-2", children: _jsx("img", { src: imageSrc, alt: alt, className: "max-w-full h-auto rounded-md border border-border" }) }, getBlockKey()));
+                                        }
+                                        // Handle diff blocks
+                                        if (block.type === "diff" &&
+                                            "path" in block &&
+                                            "oldText" in block &&
+                                            "newText" in block) {
+                                            return (_jsxs("div", { className: "border border-border rounded bg-card", children: [_jsxs("div", { className: "bg-muted px-2 py-1 text-[10px] font-mono text-muted-foreground border-b border-border", children: [block.path, "line" in block &&
+                                                                block.line !== null &&
+                                                                block.line !== undefined &&
+                                                                `:${block.line}`] }), _jsxs("div", { className: "p-2 font-mono text-[11px]", children: [_jsxs("div", { className: "text-red-500 dark:text-red-400", children: ["- ", block.oldText] }), _jsxs("div", { className: "text-green-500 dark:text-green-400", children: ["+ ", block.newText] })] })] }, getBlockKey()));
+                                        }
+                                        // Handle terminal blocks
+                                        if (block.type === "terminal" && "terminalId" in block) {
+                                            return (_jsxs("div", { className: "bg-neutral-900 text-neutral-100 p-2 rounded text-[11px] font-mono", children: ["Terminal: ", block.terminalId] }, getBlockKey()));
+                                        }
+                                        return null;
+                                    }), toolCall.error && (_jsxs("div", { className: "text-destructive font-mono text-[11px] mt-2", children: ["Error: ", toolCall.error] }))] })] })) : null, toolCall._meta?.truncationWarning && (_jsxs("div", { className: "mx-3 mt-3 mb-0 flex items-center gap-2 rounded-md bg-yellow-50 dark:bg-yellow-950/20 px-3 py-2 text-[11px] text-yellow-800 dark:text-yellow-200 border border-yellow-200 dark:border-yellow-900", children: [_jsx("span", { className: "text-yellow-600 dark:text-yellow-500", children: "\u26A0\uFE0F" }), _jsx("span", { children: toolCall._meta.truncationWarning })] })), (toolCall.tokenUsage || toolCall.startedAt) && (_jsxs("div", { className: "p-2 bg-muted/50 border-t border-border flex flex-wrap gap-4 text-[10px] text-muted-foreground font-sans", children: [toolCall.tokenUsage && (_jsxs("div", { className: "flex gap-3", children: [toolCall.tokenUsage.inputTokens !== undefined && (_jsxs("div", { children: [_jsx("span", { className: "uppercase tracking-wide font-semibold mr-1", children: "Input:" }), toolCall.tokenUsage.inputTokens.toLocaleString()] })), toolCall.tokenUsage.outputTokens !== undefined && (_jsxs("div", { children: [_jsx("span", { className: "uppercase tracking-wide font-semibold mr-1", children: "Output:" }), toolCall.tokenUsage.outputTokens.toLocaleString()] })), toolCall.tokenUsage.totalTokens !== undefined && (_jsxs("div", { children: [_jsx("span", { className: "uppercase tracking-wide font-semibold mr-1", children: "Total:" }), toolCall.tokenUsage.totalTokens.toLocaleString()] }))] })), toolCall.startedAt && (_jsxs("div", { className: "flex gap-3 ml-auto", children: [_jsxs("span", { children: ["Started: ", new Date(toolCall.startedAt).toLocaleTimeString()] }), toolCall.completedAt && (_jsxs("span", { children: ["Completed:", " ", new Date(toolCall.completedAt).toLocaleTimeString(), " (", Math.round((toolCall.completedAt - toolCall.startedAt) / 1000), "s)"] }))] }))] }))] }))] }));
+}

package/dist/gui/components/ToolCallGroup.d.ts

@@ -0,0 +1,8 @@
+import type { ToolCall as ToolCallType } from "../../core/schemas/tool-call.js";
+export interface ToolCallGroupProps {
+    toolCalls: ToolCallType[];
+}
+/**
+ * ToolCallGroup component - displays a group of parallel tool calls with collapsible details
+ */
+export declare function ToolCallGroup({ toolCalls }: ToolCallGroupProps): import("react/jsx-runtime").JSX.Element;

package/dist/gui/components/ToolCallGroup.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ChevronDown, ListVideo } from "lucide-react";
+import React, { useState } from "react";
+import { ToolCall } from "./ToolCall.js";
+/**
+ * ToolCallGroup component - displays a group of parallel tool calls with collapsible details
+ */
+export function ToolCallGroup({ toolCalls }) {
+    const [isExpanded, setIsExpanded] = useState(false);
+    // Calculate group status based on individual tool call statuses
+    const getGroupStatus = () => {
+        const statuses = toolCalls.map((tc) => tc.status);
+        if (statuses.some((s) => s === "failed"))
+            return "failed";
+        if (statuses.some((s) => s === "in_progress"))
+            return "in_progress";
+        if (statuses.every((s) => s === "completed"))
+            return "completed";
+        return "pending";
+    };
+    const groupStatus = getGroupStatus();
+    // Generate summary of tool names
+    const toolNames = toolCalls.map((tc) => tc.prettyName || tc.title);
+    const uniqueNames = [...new Set(toolNames)];
+    const summary = uniqueNames.length <= 2
+        ? uniqueNames.join(", ")
+        : `${uniqueNames.slice(0, 2).join(", ")} +${uniqueNames.length - 2} more`;
+    return (_jsxs("div", { className: "flex flex-col my-4", children: [_jsxs("button", { type: "button", className: "flex flex-col items-start gap-0.5 cursor-pointer bg-transparent border-none p-0 text-left group w-fit", onClick: () => setIsExpanded(!isExpanded), "aria-expanded": isExpanded, children: [_jsxs("div", { className: "flex items-center gap-1.5 text-[11px] font-medium text-muted-foreground", children: [_jsx("div", { className: "text-muted-foreground", children: _jsx(ListVideo, { className: "h-3 w-3" }) }), _jsx("span", { className: "text-paragraph-sm text-muted-foreground", children: "Parallel operation" }), _jsx("span", { className: "text-[10px] bg-muted px-1.5 py-0.5 rounded text-muted-foreground/70", children: toolCalls.length }), _jsx(ChevronDown, { className: `h-3 w-3 text-muted-foreground/70 transition-transform duration-200 ${isExpanded ? "rotate-180" : ""}` })] }), !isExpanded && (_jsx("span", { className: "text-paragraph-sm text-muted-foreground/70 pl-4.5", children: summary }))] }), isExpanded && (_jsx("div", { className: "mt-1", children: toolCalls.map((toolCall) => (_jsxs("div", { className: "flex items-start", children: [_jsx("div", { className: "w-2.5 h-4 border-l-2 border-b-2 border-border rounded-bl-[6px] mt-1 mr-0.5 shrink-0" }), _jsx("div", { className: "flex-1 -mt-2", children: _jsx(ToolCall, { toolCall: toolCall }) })] }, toolCall.id))) }))] }));
+}

package/dist/gui/components/ToolOperation.js

@@ -349,7 +349,9 @@ function GroupedToolCallItem({ toolCall, hookNotification, }) {
         // Render subagent with clickable header and SubAgentDetails component
         return (_jsxs("div", { className: "flex flex-col ml-5", children: [
                 _jsxs("button", { type: "button", className: "flex items-center gap-1.5 cursor-pointer bg-transparent border-none p-0 text-left group w-fit", onClick: () => setIsExpanded(!isExpanded), "aria-expanded": isExpanded, children: [
-                        _jsx("div", { className: "text-text-secondary/70 group-hover:text-text-secondary transition-colors", children: _jsx(CircleDot, { className: "h-3 w-3" }) }), _jsx("span", { className: "text-paragraph-sm text-text-secondary/70 group-hover:text-text-secondary transition-colors", children: toolCall.rawInput?.agentName || "Subagent" }), isRunning && toolCall.startedAt && (_jsx(RunningDuration, { startTime: toolCall.startedAt })), isFailed && (_jsx("span", { title: toolCall.error || "Operation failed", children: _jsx(AlertCircle, { className: "h-3 w-3 text-destructive" }) })), hasCompaction && (_jsx(TooltipProvider, { delayDuration: 0, children: _jsxs(Tooltip, { children: [
+                        _jsx("div", { className: "text-text-secondary/70 group-hover:text-text-secondary transition-colors", children: _jsx(CircleDot, { className: "h-3 w-3" }) }), _jsx("span", { className: "text-paragraph-sm text-text-secondary/70 group-hover:text-text-secondary transition-colors", children: toolCall.subagentMessages?.[0]?._meta?.semanticName ||
+                                toolCall.rawInput?.agentName ||
+                                "Subagent" }), toolCall.subagentMessages?.[0]?._meta?.semanticName && (_jsxs("span", { className: "text-muted-foreground text-[10px] ml-1", children: ["(", toolCall.rawInput?.agentName || "subagent", ")"] })), isRunning && toolCall.startedAt && (_jsx(RunningDuration, { startTime: toolCall.startedAt })), isFailed && (_jsx("span", { title: toolCall.error || "Operation failed", children: _jsx(AlertCircle, { className: "h-3 w-3 text-destructive" }) })), hasCompaction && (_jsx(TooltipProvider, { delayDuration: 0, children: _jsxs(Tooltip, { children: [
                                     _jsx(TooltipTrigger, { asChild: true, children: _jsx("span", { children: isTruncation ? (_jsx(ScissorsLineDashed, { className: "h-3 w-3 text-destructive" })) : (_jsx(FoldVertical, { className: "h-3 w-3 text-text-secondary/70" })) }) }), _jsx(TooltipContent, { children: (() => {
                                             const meta = toolCall._meta;
                                             const percentage = meta?.originalTokens && meta?.finalTokens

package/dist/sdk/schemas/session.d.ts

@@ -348,6 +348,12 @@ export declare const SessionUpdate: z.ZodUnion<readonly [z.ZodObject<{
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">>>;
             isStreaming: z.ZodOptional<z.ZodBoolean>;
+            _meta: z.ZodOptional<z.ZodObject<{
+                semanticName: z.ZodOptional<z.ZodString>;
+                agentDefinitionName: z.ZodOptional<z.ZodString>;
+                currentActivity: z.ZodOptional<z.ZodString>;
+                statusGenerating: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         subagentStreaming: z.ZodOptional<z.ZodBoolean>;
         subagentCompleted: z.ZodOptional<z.ZodBoolean>;
@@ -557,6 +563,12 @@ export declare const SessionUpdate: z.ZodUnion<readonly [z.ZodObject<{
                 }, z.core.$strip>;
             }, z.core.$strip>], "type">>>;
             isStreaming: z.ZodOptional<z.ZodBoolean>;
+            _meta: z.ZodOptional<z.ZodObject<{
+                semanticName: z.ZodOptional<z.ZodString>;
+                agentDefinitionName: z.ZodOptional<z.ZodString>;
+                currentActivity: z.ZodOptional<z.ZodString>;
+                statusGenerating: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         subagentCompleted: z.ZodOptional<z.ZodBoolean>;
         _meta: z.ZodOptional<z.ZodObject<{

package/dist/sdk/transports/http.js

@@ -872,19 +872,14 @@ export class HttpTransport {
                 message.method === "session/update" &&
                 message.params?.update?.sessionUpdate === "sources";
             if (isSourcesMessage) {
-                // Use console.warn directly for gui-console capture
-                console.warn("🟢 RECEIVED SOURCES SSE MESSAGE", {
-                    sourcesCount: message.params?.update?.sources?.length,
-                    isInReplayMode: this.isInReplayMode,
-                    callbackCount: this.sessionUpdateCallbacks.size,
-                });
                 // Handle sources directly without ACP schema validation
                 try {
                     this.handleSessionNotification(message.params);
-                    console.warn("🟢 AFTER handleSessionNotification for sources");
                 }
                 catch (error) {
-                    console.error("🔴 ERROR in handleSessionNotification for sources", error);
+                    logger.error("Error in handleSessionNotification for sources", {
+                        error,
+                    });
                 }
                 return;
             }
@@ -931,9 +926,6 @@ export class HttpTransport {
             logger.debug("Skipping session notification - stream complete/cancelled");
             return;
         }
-        if (this.streamComplete && isSourcesNotification) {
-            console.warn("🟢 Processing sources notification after stream complete");
-        }
         logger.debug("handleSessionNotification called", { params });
         // Extract content from the update
         const paramsExtended = params;
@@ -1548,13 +1540,6 @@ export class HttpTransport {
             update.sessionUpdate === "sources") {
             // Sources notification - citation sources from tool calls
             const sourcesUpdate = update;
-            console.warn("🔵 SOURCES in handleSessionNotification", {
-                sourcesCount: sourcesUpdate.sources.length,
-                isInReplayMode: this.isInReplayMode,
-                callbackCount: this.sessionUpdateCallbacks.size,
-                firstSourceId: sourcesUpdate.sources[0]?.id,
-                firstSourceToolCallId: sourcesUpdate.sources[0]?.toolCallId,
-            });
             // Create a sources session update
             const sessionUpdate = {
                 type: "sources",
@@ -1567,20 +1552,9 @@ export class HttpTransport {
                 // If no callbacks are registered yet (React hooks haven't subscribed),
                 // queue the sources to be replayed when they do subscribe
                 if (this.sessionUpdateCallbacks.size === 0) {
-                    console.warn("🔵 QUEUEING sources for late-subscribing callbacks", {
-                        sourcesCount: sourcesUpdate.sources.length,
-                        queueLengthBefore: this.pendingReplayUpdates.length,
-                    });
                     this.pendingReplayUpdates.push(sessionUpdate);
-                    console.warn("🔵 Queue length after:", {
-                        queueLengthAfter: this.pendingReplayUpdates.length,
-                    });
                 }
                 else {
-                    console.warn("🔵 NOTIFYING sources immediately (callbacks registered)", {
-                        sourcesCount: sourcesUpdate.sources.length,
-                        callbackCount: this.sessionUpdateCallbacks.size,
-                    });
                     this.notifySessionUpdate(sessionUpdate);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@townco/ui",
-  "version": "0.1.110",
+  "version": "0.1.112",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -49,7 +49,7 @@
     "@radix-ui/react-slot": "^1.2.4",
     "@radix-ui/react-tabs": "^1.1.13",
     "@radix-ui/react-tooltip": "^1.2.8",
-    "@townco/core": "0.0.88",
+    "@townco/core": "0.0.90",
     "@types/mdast": "^4.0.4",
     "@uiw/react-json-view": "^2.0.0-alpha.39",
     "class-variance-authority": "^0.7.1",
@@ -67,7 +67,7 @@
     "zustand": "^5.0.8"
   },
   "devDependencies": {
-    "@townco/tsconfig": "0.1.107",
+    "@townco/tsconfig": "0.1.109",
     "@types/node": "^24.10.0",
     "@types/react": "^19.2.2",
     "@types/unist": "^3.0.3",