@timetotest/cli 0.1.10 → 0.2.0

package/dist/src/lib/tui/events.js

@@ -1,11 +1,70 @@
 import chalk from "chalk";
 import { icons } from "./icons.js";
-import { stripAnsi, sanitizeText, asPercent, safeCount, formatKeyValues, formatTimestamp, isPlainObject, } from "./utils.js";
+import { stripAnsi, sanitizeText, asPercent, safeCount, formatKeyValues, formatTimestamp, isPlainObject, summarizeList, } from "./utils.js";
+const toolIconMap = {
+    // Browser tools
+    browser_session: "tool",
+    browser_navigate: "navigate",
+    browser_take_screenshot: "screenshotTool",
+    browser_click: "click",
+    browser_hover: "hover",
+    browser_type: "type",
+    browser_fill_form: "form",
+    browser_select_option: "select",
+    browser_press_key: "keypress",
+    browser_wait_for: "wait",
+    browser_handle_dialog: "dialog",
+    browser_tabs: "tabs",
+    browser_resize: "resize",
+    browser_drag: "drag",
+    browser_snapshot_query: "snapshot",
+    browser_network_requests: "tool",
+    browser_console_messages: "tool",
+    // API tools
+    api_discovery: "tool",
+    build_api_request: "tool",
+    generate_curl: "tool",
+    generate_api_test: "tool",
+    search_discovered_endpoints: "tool",
+    get_api_parameters: "tool",
+    get_api: "tool",
+    post_api: "tool",
+    put_api: "tool",
+    patch_api: "tool",
+    delete_api: "tool",
+    validate_api_response: "tool",
+    assert_response_schema: "tool",
+    api_request: "tool",
+    extract_response_fields: "tool",
+    set_auth_header: "tool",
+    // General tools
+    set_testing_mode: "tool",
+    finish: "done",
+    finish_overall_test: "done",
+    generate_test_cases: "cases",
+    // Legacy tool names (for backward compatibility)
+    navigate: "navigate",
+    click_element: "click",
+    hover_element: "hover",
+    type_text: "type",
+    screenshot: "screenshotTool",
+    search_interactive_elements: "tool",
+    manage_tab: "tabs",
+    page_discovery: "tool",
+};
 const EVENT_META = {
-    test_started: { icon: icons.start, label: "test_started", color: chalk.bold },
-    test_progress: { icon: icons.progress, label: "progress", color: chalk.cyan },
-    test_completed: { icon: icons.done, label: "completed", color: chalk.green },
-    test_failed: { icon: icons.fail, label: "failed", color: chalk.red },
+    session_started: {
+        icon: icons.start,
+        label: "session_started",
+        color: chalk.bold,
+    },
+    session_progress: {
+        icon: icons.progress,
+        label: "progress",
+        color: chalk.cyan,
+    },
+    session_completed: { icon: icons.done, label: "completed", color: chalk.green },
+    session_error: { icon: icons.fail, label: "error", color: chalk.red },
     browser_initialized: {
         icon: icons.browser,
         label: "browser",
@@ -39,31 +98,12 @@ const EVENT_META = {
         label: "test_cases",
         color: chalk.magenta,
     },
-    test_execution_started: {
-        icon: icons.exec,
-        label: "execution",
-        color: chalk.yellow,
-    },
-    test_execution_progress: {
+    agent_thinking_started: {
         icon: icons.exec,
-        label: "execution",
-        color: chalk.yellow,
-    },
-    test_execution_completed: {
-        icon: icons.done,
-        label: "execution",
-        color: chalk.green,
-    },
-    test_execution_failed: {
-        icon: icons.fail,
-        label: "execution",
-        color: chalk.red,
-    },
-    test_execution_stopped: {
-        icon: icons.warn,
-        label: "execution",
-        color: chalk.yellow,
+        label: "agent_think",
+        color: chalk.magenta,
     },
+    session_stopped: { icon: icons.warn, label: "stopped", color: chalk.yellow },
     test_case_execution_started: {
         icon: icons.exec,
         label: "test_case",
@@ -84,7 +124,7 @@ const EVENT_META = {
         label: "step_shot",
         color: chalk.cyan,
     },
-    test_step_user_input_required: {
+    user_input_required: {
         icon: icons.user,
         label: "user_input",
         color: chalk.yellow,
@@ -105,27 +145,23 @@ const EVENT_META = {
         label: "user_input",
         color: chalk.red,
     },
-    agent_thinking_started: {
-        icon: icons.think,
-        label: "agent",
-        color: chalk.magenta,
-    },
     agent_thinking_stopped: {
         icon: icons.think,
         label: "agent",
         color: chalk.magenta,
     },
-    agent_thought_process: {
-        icon: icons.think,
-        label: "agent",
-        color: chalk.magenta,
-    },
+    agent_thought: { icon: icons.think, label: "agent", color: chalk.magenta },
     agent_plan_generated: {
         icon: icons.plan,
         label: "agent_plan",
         color: chalk.magenta,
     },
-    agent_tool_execution: {
+    agent_tool_start: {
+        icon: icons.tool,
+        label: "agent_tool",
+        color: chalk.magenta,
+    },
+    agent_tool_result: {
         icon: icons.tool,
         label: "agent_tool",
         color: chalk.magenta,
@@ -164,23 +200,12 @@ const EVENT_META = {
     error: { icon: icons.fail, label: "error", color: chalk.red },
     stats_response: { icon: icons.info, label: "stats", color: chalk.gray },
     pong: { icon: icons.info, label: "pong", color: chalk.white },
-    ask_thinking_started: { icon: icons.think, label: "ask", color: chalk.magenta },
-    ask_thinking_stopped: { icon: icons.think, label: "ask", color: chalk.magenta },
-    ask_agent_thought: { icon: icons.think, label: "ask", color: chalk.magenta },
-    ask_tool_start: { icon: icons.tool, label: "ask_tool", color: chalk.magenta },
-    ask_tool_result: { icon: icons.tool, label: "ask_tool", color: chalk.magenta },
-    ask_agent_answer: {
-        icon: icons.plan,
-        label: "ask_answer",
-        color: chalk.magenta,
-    },
-    ask_user_message: { icon: icons.info, label: "ask_user", color: chalk.white },
-    ask_session_completed: {
-        icon: icons.done,
-        label: "ask_session",
-        color: chalk.green,
-    },
-    ask_session_error: { icon: icons.fail, label: "ask_session", color: chalk.red },
+    thinking_started: { icon: icons.think, label: "ask", color: chalk.magenta },
+    thinking_stopped: { icon: icons.think, label: "ask", color: chalk.magenta },
+    tool_start: { icon: icons.tool, label: "ask_tool", color: chalk.magenta },
+    tool_result: { icon: icons.tool, label: "ask_tool", color: chalk.magenta },
+    agent_answer: { icon: icons.plan, label: "ask_answer", color: chalk.magenta },
+    user_message: { icon: icons.info, label: "user_message", color: chalk.white },
 };
 export function formatEventLines(type, payload) {
     const base = isPlainObject(payload) ? payload : {};
@@ -208,21 +233,51 @@ export function formatEventLines(type, payload) {
         ? descriptor.color(descriptor.label)
         : descriptor.label;
     const timestamp = formatTimestamp(base.timestamp);
-    const testIdSource = base.test_id ??
+    const sessionKind = base.session_kind || eventData.session_kind;
+    const sessionIdsRaw = (isPlainObject(base.ids) && base.ids) ||
+        (isPlainObject(eventData.ids) && eventData.ids) ||
+        {};
+    const sessionIds = isPlainObject(sessionIdsRaw)
+        ? sessionIdsRaw
+        : {};
+    const parentRaw = base.parent || eventData.parent;
+    const parent = isPlainObject(parentRaw)
+        ? parentRaw
+        : undefined;
+    const actorRaw = base.actor || eventData.actor;
+    const actor = isPlainObject(actorRaw)
+        ? actorRaw
+        : undefined;
+    const correlationId = base.correlation_id || eventData.correlation_id;
+    const sanitizeId = (value) => sanitizeText(value, { maxLength: 48 }) || "";
+    const badgeParts = [];
+    const testIdValue = sanitizeId(sessionIds.test_id ??
+        base.test_id ??
         eventData.test_id ??
         (isPlainObject(base.data)
             ? base.data.test_id
-            : undefined);
-    const testIdValue = sanitizeText(testIdSource, { maxLength: 32 });
-    const testIdPart = testIdValue ? chalk.gray(`#${testIdValue}`) : "";
+            : undefined));
+    if (testIdValue)
+        badgeParts.push(`#${testIdValue}`);
+    const conversationIdValue = sanitizeId(sessionIds.conversation_id ??
+        base.conversation_id ??
+        eventData.conversation_id);
+    if (conversationIdValue)
+        badgeParts.push(`ask:${conversationIdValue}`);
+    const subagentIdValue = sanitizeId(sessionIds.subagent_id ??
+        base.subagent_id ??
+        eventData.subagent_id);
+    if (subagentIdValue)
+        badgeParts.push(`sub:${subagentIdValue}`);
+    const sessionBadge = badgeParts.length > 0 ? chalk.gray(badgeParts.join(" · ")) : "";
     const lines = [];
     const additional = [];
     const ensureExtra = (value) => value && stripAnsi(value).length > 0 ? value : undefined;
     const addLine = (icon, labelText, message, extra) => {
         const iconToUse = icon || icons.info;
         const parts = [`${timestamp} ${iconToUse} ${labelText}`];
-        if (testIdPart)
-            parts.push(testIdPart);
+        if (sessionBadge)
+            parts.push(sessionBadge);
         if (message)
             parts.push(message);
         if (extra)
@@ -265,27 +320,57 @@ export function formatEventLines(type, payload) {
     })();
     let extra;
     const detailLines = [];
-    // Switch with identical logic as original file
+    if (parent) {
+        const parentLabel = `parent:${sanitizeText(parent.session_kind) || ""}`;
+        const parentIds = isPlainObject(parent.ids)
+            ? parent.ids
+            : {};
+        const parentExtra = ensureExtra(formatKeyValues([
+            ["test_id", sanitizeId(parentIds.test_id)],
+            ["conversation_id", sanitizeId(parentIds.conversation_id)],
+            ["subagent_id", sanitizeId(parentIds.subagent_id)],
+        ]));
+        additional.push({
+            icon: icons.link,
+            label: parentLabel.trim(),
+            extra: parentExtra,
+        });
+    }
+    if (actor) {
+        const actorLabel = `actor:${sanitizeText(actor.role) || ""}`.trim();
+        const actorExtra = ensureExtra(formatKeyValues([
+            ["id", sanitizeId(actor.id)],
+            ["kind", sanitizeText(actor.kind || actor.type)],
+        ]));
+        additional.push({
+            icon: icons.user,
+            label: actorLabel || "actor",
+            extra: actorExtra,
+        });
+    }
     switch (normalizedType) {
-        // The entire switch body is preserved verbatim from the original file
-        // for fidelity and to avoid behavior changes.
-        case "test_started": {
+        case "session_started": {
             if (!eventMessage)
-                eventMessage = "Test started";
+                eventMessage = "Session started";
             extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
                 ["type", sanitizeText(eventData.test_type)],
                 ["mode", sanitizeText(eventData.execution_mode)],
                 ["execute", eventData.execute_tests ? "yes" : undefined],
                 ["project", safeCount(eventData.project_id)],
+                ["test_id", safeCount(sessionIds.test_id)],
+                ["conversation_id", sanitizeText(sessionIds.conversation_id)],
+                ["subagent_id", safeCount(sessionIds.subagent_id)],
             ]));
             break;
         }
-        case "test_progress": {
+        case "session_progress": {
             if (!eventMessage)
                 eventMessage = "Progress update";
             const progressValue = asPercent(eventData.progress_percentage ?? eventData.progress) ??
                 safeCount(eventData.progress_percentage ?? eventData.progress);
             extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
                 ["progress", progressValue],
                 ["stage", sanitizeText(eventData.stage)],
                 [
@@ -300,18 +385,573 @@ export function formatEventLines(type, payload) {
             ]));
             break;
         }
-        // ... full switch cases continue unchanged ...
-        default: {
+        case "session_completed": {
             if (!eventMessage)
-                eventMessage = derivedType || "event";
+                eventMessage = "Session completed";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["status", sanitizeText(eventData.status)],
+                ["test_id", safeCount(sessionIds.test_id)],
+                ["conversation_id", sanitizeText(sessionIds.conversation_id)],
+            ]));
+            break;
+        }
+        case "session_error": {
+            if (!eventMessage)
+                eventMessage = "Session error";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["error", sanitizeText(eventData.error)],
+                ["test_id", safeCount(sessionIds.test_id)],
+                ["conversation_id", sanitizeText(sessionIds.conversation_id)],
+            ]));
+            break;
+        }
+        case "user_input_required": {
+            if (!eventMessage)
+                eventMessage = "User input required";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["request_id", sanitizeText(eventData.request_id)],
+                ["correlation_id", sanitizeText(correlationId)],
+            ]));
+            break;
+        }
+        case "agent_thinking_started":
+        case "thinking_started": {
+            if (!eventMessage)
+                eventMessage = "Agent thinking";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["actor", sanitizeText(actor?.role)],
+                ["correlation_id", sanitizeText(correlationId)],
+            ]));
+            break;
+        }
+        case "agent_tool_start":
+        case "tool_start": {
+            if (!eventMessage)
+                eventMessage = "Tool execution";
+            const rawToolName = eventData.tool || eventData.tool_name || "";
+            const toolName = sanitizeText(rawToolName);
+            // Try to find the icon key by checking multiple variations
+            let iconKey = toolIconMap[toolName] || toolIconMap[rawToolName] || "tool";
+            // If still not found, try common variations
+            if (iconKey === "tool") {
+                // Try with "mcp_" prefix removed
+                const withoutMcpPrefix = toolName.replace(/^mcp_/, "");
+                iconKey =
+                    toolIconMap[withoutMcpPrefix] ||
+                        toolIconMap[rawToolName.replace(/^mcp_/, "")] ||
+                        "tool";
+            }
+            // Try with underscores replaced by hyphens (common variation)
+            if (iconKey === "tool") {
+                const withHyphens = toolName.replace(/_/g, "-");
+                const rawWithHyphens = rawToolName.replace(/_/g, "-");
+                iconKey =
+                    toolIconMap[withHyphens] || toolIconMap[rawWithHyphens] || "tool";
+            }
+            // Try with spaces instead of underscores
+            if (iconKey === "tool") {
+                const withSpaces = toolName.replace(/_/g, " ");
+                const rawWithSpaces = rawToolName.replace(/_/g, " ");
+                iconKey =
+                    toolIconMap[withSpaces] || toolIconMap[rawWithSpaces] || "tool";
+            }
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["tool", toolName],
+                ["actor", sanitizeText(actor?.role)],
+                ["correlation_id", sanitizeText(correlationId)],
+            ]));
+            descriptor.icon = icons[iconKey] || icons.tool;
+            break;
+        }
+        case "agent_tool_result":
+        case "tool_result": {
+            if (!eventMessage)
+                eventMessage = "Tool completed";
+            const rawToolName = eventData.tool || eventData.tool_name || "";
+            const toolName = sanitizeText(rawToolName);
+            // Try to find the icon key by checking multiple variations
+            let iconKey = toolIconMap[toolName] || toolIconMap[rawToolName] || "tool";
+            // If still not found, try common variations
+            if (iconKey === "tool") {
+                // Try with "mcp_" prefix removed
+                const withoutMcpPrefix = toolName.replace(/^mcp_/, "");
+                iconKey =
+                    toolIconMap[withoutMcpPrefix] ||
+                        toolIconMap[rawToolName.replace(/^mcp_/, "")] ||
+                        "tool";
+            }
+            // Try with underscores replaced by hyphens (common variation)
+            if (iconKey === "tool") {
+                const withHyphens = toolName.replace(/_/g, "-");
+                const rawWithHyphens = rawToolName.replace(/_/g, "-");
+                iconKey =
+                    toolIconMap[withHyphens] || toolIconMap[rawWithHyphens] || "tool";
+            }
+            // Try with spaces instead of underscores
+            if (iconKey === "tool") {
+                const withSpaces = toolName.replace(/_/g, " ");
+                const rawWithSpaces = rawToolName.replace(/_/g, " ");
+                iconKey =
+                    toolIconMap[withSpaces] || toolIconMap[rawWithSpaces] || "tool";
+            }
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["tool", toolName],
+                ["actor", sanitizeText(actor?.role)],
+                ["correlation_id", sanitizeText(correlationId)],
+            ]));
+            descriptor.icon = icons[iconKey] || icons.tool;
+            break;
+        }
+        case "browser_initialized": {
+            if (!eventMessage)
+                eventMessage = "Browser initialized";
+            const browserInfo = isPlainObject(eventData.browser_info)
+                ? eventData.browser_info
+                : {};
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["phase", sanitizeText(eventData.phase)],
+                ["browser", sanitizeText(browserInfo.name ?? browserInfo.browser)],
+                ["version", sanitizeText(browserInfo.version)],
+                [
+                    "mode",
+                    browserInfo.headless === undefined
+                        ? undefined
+                        : browserInfo.headless
+                            ? "headless"
+                            : "headed",
+                ],
+            ]));
+            break;
+        }
+        case "page_discovered": {
+            if (!eventMessage)
+                eventMessage = "Pages discovered";
+            const pages = Array.isArray(eventData.discovered_pages)
+                ? eventData.discovered_pages
+                : [];
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["count", safeCount(pages.length)],
+                ["total", safeCount(eventData.total_pages)],
+            ]));
+            if (pages.length) {
+                const listings = pages
+                    .map((p) => sanitizeText(p) || "")
+                    .filter(Boolean);
+                if (listings.length) {
+                    detailLines.push("Pages discovered:");
+                    detailLines.push(...summarizeList(listings, 6));
+                }
+            }
+            break;
+        }
+        case "page_processing": {
+            if (!eventMessage)
+                eventMessage =
+                    sanitizeText(eventData.processing_stage) ||
+                        "Processing page";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["stage", sanitizeText(eventData.processing_stage)],
+                ["url", sanitizeText(eventData.page_url)],
+            ]));
+            break;
+        }
+        case "screenshot_captured":
+        case "screenshot_with_analysis": {
+            if (!eventMessage)
+                eventMessage = "Screenshot captured";
+            const metadata = isPlainObject(eventData.metadata)
+                ? eventData.metadata
+                : {};
+            let resolution;
+            if (isPlainObject(metadata.dimensions)) {
+                const dims = metadata.dimensions;
+                const width = sanitizeText(dims.width);
+                const height = sanitizeText(dims.height);
+                resolution =
+                    width && height ? `${width}×${height}` : width || height || undefined;
+            }
+            else {
+                const dimText = sanitizeText(metadata.dimensions);
+                resolution = dimText || undefined;
+            }
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["url", sanitizeText(eventData.page_url)],
+                ["path", sanitizeText(eventData.screenshot_path)],
+                ["resolution", resolution],
+                ["size", safeCount(metadata.file_size)],
+            ]));
+            const analysisSummary = sanitizeText(eventData.analysis_summary, { preserveNewlines: true });
+            if (analysisSummary) {
+                detailLines.push(analysisSummary);
+            }
+            break;
+        }
+        case "page_analyzed": {
+            if (!eventMessage)
+                eventMessage = "Page analyzed";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["url", sanitizeText(eventData.page_url)],
+                ["status", sanitizeText(eventData.status)],
+            ]));
+            const insights = sanitizeText(eventData.insights, {
+                preserveNewlines: true,
+            });
+            if (insights) {
+                detailLines.push(insights);
+            }
+            break;
+        }
+        case "ai_analysis_started": {
+            if (!eventMessage)
+                eventMessage = "AI analysis started";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["analysis_id", sanitizeText(eventData.analysis_id)],
+            ]));
+            break;
+        }
+        case "ai_analysis_completed": {
+            if (!eventMessage)
+                eventMessage = "AI analysis completed";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["analysis_id", sanitizeText(eventData.analysis_id)],
+                ["status", sanitizeText(eventData.status)],
+            ]));
+            const summary = sanitizeText(eventData.summary, {
+                preserveNewlines: true,
+            });
+            if (summary) {
+                detailLines.push(summary);
+            }
+            break;
+        }
+        case "test_cases_generated": {
+            if (!eventMessage)
+                eventMessage = "Test cases generated";
+            const cases = Array.isArray(eventData.cases)
+                ? eventData.cases
+                : [];
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["count", safeCount(cases.length || eventData.count)],
+            ]));
+            if (cases.length) {
+                const items = cases
+                    .map((testCase) => {
+                    if (isPlainObject(testCase)) {
+                        return (sanitizeText(testCase.name ??
+                            testCase.title) || "");
+                    }
+                    return sanitizeText(testCase) || "";
+                })
+                    .filter(Boolean);
+                if (items.length) {
+                    detailLines.push("Generated cases:");
+                    detailLines.push(...summarizeList(items, 6));
+                }
+            }
+            break;
+        }
+        case "test_case_execution_started": {
+            if (!eventMessage)
+                eventMessage = "Test case started";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["case", sanitizeText(eventData.case_name)],
+                ["id", sanitizeText(eventData.test_case_id)],
+            ]));
+            break;
+        }
+        case "test_case_execution_completed": {
+            if (!eventMessage)
+                eventMessage = "Test case completed";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["case", sanitizeText(eventData.case_name)],
+                ["status", sanitizeText(eventData.status)],
+                ["duration", sanitizeText(eventData.duration)],
+            ]));
+            break;
+        }
+        case "test_step_execution": {
+            if (!eventMessage)
+                eventMessage = "Test step update";
+            const step = eventData.step || eventData.step_data;
             extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
                 [
-                    "status",
-                    chalk
-                        ? chalk.white(sanitizeText(eventData.status))
-                        : sanitizeText(eventData.status),
+                    "step",
+                    safeCount(step?.step_number ?? eventData.step_number),
                 ],
+                [
+                    "action",
+                    sanitizeText(step?.action ?? eventData.action),
+                ],
+                [
+                    "target",
+                    sanitizeText(step?.target ?? eventData.target),
+                ],
+                ["status", sanitizeText(eventData.status)],
+            ]));
+            break;
+        }
+        case "test_step_screenshot": {
+            if (!eventMessage)
+                eventMessage = "Step screenshot";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["step", safeCount(eventData.step_number)],
+                ["url", sanitizeText(eventData.page_url)],
+            ]));
+            break;
+        }
+        case "user_input_provided": {
+            if (!eventMessage)
+                eventMessage = "User input provided";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["request_id", sanitizeText(eventData.request_id)],
+                ["correlation_id", sanitizeText(correlationId)],
+            ]));
+            break;
+        }
+        case "user_input_acknowledged": {
+            if (!eventMessage)
+                eventMessage = "User input acknowledged";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["request_id", sanitizeText(eventData.request_id)],
+            ]));
+            break;
+        }
+        case "user_input_timeout": {
+            if (!eventMessage)
+                eventMessage = "User input timed out";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["request_id", sanitizeText(eventData.request_id)],
+                ["timeout", safeCount(eventData.timeout_seconds)],
+            ]));
+            break;
+        }
+        case "user_input_cancelled": {
+            if (!eventMessage)
+                eventMessage = "User input cancelled";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["request_id", sanitizeText(eventData.request_id)],
+                ["reason", sanitizeText(eventData.reason)],
+            ]));
+            break;
+        }
+        case "agent_thinking_stopped":
+        case "thinking_stopped": {
+            if (!eventMessage)
+                eventMessage = "Thinking completed";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["actor", sanitizeText(actor?.role)],
+                ["correlation_id", sanitizeText(correlationId)],
+            ]));
+            break;
+        }
+        case "agent_thought": {
+            if (!eventMessage)
+                eventMessage =
+                    sanitizeText(eventData.message) ||
+                        sanitizeText(eventData.content) ||
+                        "Agent thought";
+            const detail = sanitizeText(eventData.detail || eventData.analysis, { preserveNewlines: true });
+            if (detail)
+                detailLines.push(detail);
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["correlation_id", sanitizeText(correlationId)],
+            ]));
+            break;
+        }
+        case "agent_plan_generated": {
+            if (!eventMessage)
+                eventMessage = "Plan generated";
+            const steps = Array.isArray(eventData.steps)
+                ? eventData.steps
+                : [];
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["steps", safeCount(steps.length)],
+            ]));
+            if (steps.length) {
+                const stepSummaries = steps
+                    .map((step) => {
+                    if (isPlainObject(step)) {
+                        return (sanitizeText(step.summary ??
+                            step.description ??
+                            step.title) || "");
+                    }
+                    return sanitizeText(step) || "";
+                })
+                    .filter(Boolean);
+                if (stepSummaries.length) {
+                    detailLines.push("Plan:");
+                    detailLines.push(...summarizeList(stepSummaries, 6));
+                }
+            }
+            break;
+        }
+        case "agent_step_completed": {
+            if (!eventMessage)
+                eventMessage = "Agent step completed";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["step", sanitizeText(eventData.step_name)],
+                ["status", sanitizeText(eventData.status)],
+            ]));
+            break;
+        }
+        case "agent_recovery_attempt": {
+            if (!eventMessage)
+                eventMessage = "Recovery attempt";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["attempt", safeCount(eventData.attempt)],
+                ["reason", sanitizeText(eventData.reason)],
+            ]));
+            break;
+        }
+        case "agent_error": {
+            if (!eventMessage)
+                eventMessage = "Agent error";
+            const detail = sanitizeText(eventData.stack, {
+                preserveNewlines: true,
+            }) ||
+                sanitizeText(eventData.detail, {
+                    preserveNewlines: true,
+                });
+            if (detail)
+                detailLines.push(detail);
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["error", sanitizeText(eventData.error)],
+                ["code", sanitizeText(eventData.error_code)],
+            ]));
+            break;
+        }
+        case "browser_stream_started":
+        case "browser_stream_stopped": {
+            if (!eventMessage)
+                eventMessage =
+                    normalizedType === "browser_stream_started"
+                        ? "Browser stream started"
+                        : "Browser stream stopped";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["url", sanitizeText(eventData.stream_url)],
+            ]));
+            break;
+        }
+        case "subscription_confirmed":
+        case "subscription_removed": {
+            if (!eventMessage)
+                eventMessage = "Subscription update";
+            const selectorParts = [];
+            const selectorTestId = sanitizeId(sessionIds.test_id);
+            if (selectorTestId) {
+                selectorParts.push(`test_id=${selectorTestId}`);
+            }
+            const selectorConversationId = sanitizeId(sessionIds.conversation_id);
+            if (selectorConversationId) {
+                selectorParts.push(`conversation_id=${selectorConversationId}`);
+            }
+            const selectorSubagentId = sanitizeId(sessionIds.subagent_id);
+            if (selectorSubagentId) {
+                selectorParts.push(`subagent_id=${selectorSubagentId}`);
+            }
+            const selectorDisplay = selectorParts.join(" ");
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["selector", selectorDisplay],
+            ]));
+            break;
+        }
+        case "tool_screenshot": {
+            if (!eventMessage)
+                eventMessage = "Tool screenshot";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["url", sanitizeText(eventData.image_url)],
+                ["correlation_id", sanitizeText(correlationId)],
+            ]));
+            break;
+        }
+        case "stats_response": {
+            if (!eventMessage)
+                eventMessage = "Stats received";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["duration_ms", safeCount(eventData.duration_ms)],
+                ["connections", safeCount(eventData.connection_count)],
+            ]));
+            if (isPlainObject(eventData.stats)) {
+                const statsLine = formatKeyValues(Object.entries(eventData.stats).map(([key, value]) => [
+                    key,
+                    sanitizeText(value),
+                ]));
+                if (statsLine) {
+                    detailLines.push("Stats:");
+                    detailLines.push(statsLine);
+                }
+            }
+            break;
+        }
+        case "pong": {
+            if (!eventMessage)
+                eventMessage = "Pong";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["latency_ms", safeCount(eventData.latency_ms)],
+            ]));
+            break;
+        }
+        case "agent_answer": {
+            if (!eventMessage)
+                eventMessage = "Agent answer";
+            const summary = sanitizeText(eventData.summary, {
+                preserveNewlines: true,
+            });
+            if (summary)
+                detailLines.push(summary);
+            break;
+        }
+        case "user_message": {
+            if (!eventMessage)
+                eventMessage = "User message";
+            const content = sanitizeText(eventData.content, {
+                preserveNewlines: true,
+            });
+            if (content)
+                detailLines.push(content);
+            break;
+        }
+        default: {
+            if (!eventMessage)
+                eventMessage = derivedType || "event";
+            extra = ensureExtra(formatKeyValues([
+                ["kind", sanitizeText(sessionKind)],
+                ["status", sanitizeText(eventData.status)],
                 ["code", sanitizeText(eventData.error_code)],
+                ["correlation_id", sanitizeText(correlationId)],
             ]));
         }
     }