@drisp/cli 0.4.2 → 0.4.5

package/dist/cli.js

@@ -3,7 +3,7 @@ import "./chunk-HXBCZAP7.js";
 import {
   channelSidecarDir,
   rotateGatewayToken
-} from "./chunk-6TJHAUNB.js";
+} from "./chunk-M44KEGM7.js";
 import {
   CREDENTIAL_SOURCES_TRIED,
   EXEC_EXIT_CODE,
@@ -34,8 +34,9 @@ import {
   getGlyphs,
   getMostRecentAthenaSession,
   getSessionMeta,
-  handleEvent,
   hintGlyphs,
+  ingestRuntimeDecision,
+  ingestRuntimeEvent,
   isScopedPermissionsRequest,
   isSubagentTool,
   isSupportedGatewayUrl,
@@ -49,10 +50,12 @@ import {
   probeSkipReason,
   processRegistry,
   progressGlyphs,
+  readAttachmentMirror,
   readGatewayClientConfig,
   readPidLock,
   register,
   registerCleanupOnExit,
+  removeAttachmentMirror,
   resolveClaudeBinary,
   resolveClaudeSettingsSurfacePaths,
   resolveHarnessAdapter,
@@ -67,9 +70,10 @@ import {
   startSessionBridge,
   supportsSessionApproval,
   todoGlyphSet,
+  writeAttachmentMirror,
   writeGatewayClientConfig,
   wsClientOptionsForEndpoint
-} from "./chunk-WHELLVBL.js";
+} from "./chunk-PJUDHH4R.js";
 import {
   generateId as generateId2
 } from "./chunk-BTKQ67RE.js";
@@ -128,7 +132,7 @@ import {
   useWorkflowSessionController,
   writeGlobalConfig,
   writeProjectConfig
-} from "./chunk-GE6PPB6Z.js";
+} from "./chunk-5VK2ZMVV.js";
 
 // src/app/entry/cli.tsx
 import { render } from "ink";
@@ -144,7 +148,7 @@ import process6 from "process";
 import React9, {
   Profiler,
   useState as useState18,
-  useCallback as useCallback18,
+  useCallback as useCallback19,
   useRef as useRef16,
   useEffect as useEffect14,
   useMemo as useMemo17
@@ -1726,7 +1730,7 @@ function useFeed(runtime, messages = [], initialAllowedTools, sessionStore, opti
   const [isServerRunning, setIsServerRunning] = useState4(
     () => runtime.getStatus() === "running"
   );
-  const [runtimeError, setRuntimeError] = useState4(
+  const [runtimeError2, setRuntimeError] = useState4(
     () => runtime.getLastError()
   );
   const restoredTokens = useMemo3(
@@ -1934,19 +1938,16 @@ function useFeed(runtime, messages = [], initialAllowedTools, sessionStore, opti
             `useFeed permission event relay-enabled id=${runtimeEvent.id} tool=${runtimeEvent.toolName ?? ""}`
           );
         }
-        const result = handleEvent(runtimeEvent, controllerCallbacks);
-        if (result.handled && result.decision) {
-          runtime.sendDecision(runtimeEvent.id, result.decision);
-        }
-        const newFeedEvents = mapperRef.current.mapEvent(runtimeEvent);
-        if (sessionStoreRef.current) {
-          try {
-            sessionStoreRef.current.recordEvent(runtimeEvent, newFeedEvents);
-          } catch (err) {
-            sessionStoreRef.current.markDegraded(
-              `recordEvent failed: ${err instanceof Error ? err.message : err}`
-            );
+        const { feedEvents: newFeedEvents, decision } = ingestRuntimeEvent(
+          runtimeEvent,
+          {
+            mapper: mapperRef.current,
+            store: sessionStoreRef.current,
+            controllerCallbacks
           }
+        );
+        if (decision) {
+          runtime.sendDecision(runtimeEvent.id, decision);
         }
         if (!abortRef.current.signal.aborted && newFeedEvents.length > 0) {
           for (const fe of newFeedEvents) {
@@ -1984,17 +1985,11 @@ function useFeed(runtime, messages = [], initialAllowedTools, sessionStore, opti
           if (decision.intent?.kind === "question_answer" || decision.source === "timeout") {
             dequeueQuestion(eventId);
           }
-          const feedEvent = mapperRef.current.mapDecision(eventId, decision);
+          const feedEvent = ingestRuntimeDecision(eventId, decision, {
+            mapper: mapperRef.current,
+            store: sessionStoreRef.current
+          });
           if (feedEvent) {
-            if (sessionStoreRef.current) {
-              try {
-                sessionStoreRef.current.recordFeedEvents([feedEvent]);
-              } catch (err) {
-                sessionStoreRef.current.markDegraded(
-                  `recordFeedEvents failed: ${err instanceof Error ? err.message : err}`
-                );
-              }
-            }
             feedStoreRef.current.pushEvents([feedEvent]);
             if (feedEvent.kind === "permission.decision" && feedEvent.cause?.hook_request_id) {
               dequeuePermission(feedEvent.cause.hook_request_id);
@@ -2049,7 +2044,7 @@ function useFeed(runtime, messages = [], initialAllowedTools, sessionStore, opti
     currentRun: mapperRef.current.getCurrentRun(),
     actors: mapperRef.current.getActors(),
     isServerRunning,
-    runtimeError,
+    runtimeError: runtimeError2,
     currentPermissionRequest,
     permissionQueueCount: permissionQueue.length,
     resolvePermission,
@@ -5018,31 +5013,7 @@ function useTodoDisplayItems({
 }
 
 // src/ui/hooks/useTimeline.ts
-import { useMemo as useMemo9, useRef as useRef9 } from "react";
-
-// src/core/feed/defaultRender.ts
-var DEFAULT_RENDER = /* @__PURE__ */ new Set([
-  "compact.post",
-  "task.created",
-  "cwd.changed",
-  "file.changed",
-  "stop.failure",
-  "permission.denied",
-  "elicitation.request",
-  "elicitation.result",
-  "channel.permission.relayed",
-  "channel.permission.resolved",
-  "channel.question.relayed",
-  "channel.question.resolved",
-  "channel.chat.inbound",
-  "channel.chat.outbound",
-  "gateway.function.invoked",
-  "gateway.function.completed",
-  "gateway.function.failed"
-]);
-function isDefaultRenderKind(k) {
-  return DEFAULT_RENDER.has(k);
-}
+import { useMemo as useMemo9, useRef as useRef9, useCallback as useCallback10 } from "react";
 
 // src/shared/utils/toolResponse.ts
 function isRecord(value) {
@@ -5267,207 +5238,24 @@ function computeDuplicateActors(entries) {
     entries[i].duplicateActor = sameActor && !isBreak;
   }
 }
-function eventOperation(event) {
-  if (isDefaultRenderKind(event.kind)) return "event";
-  switch (event.kind) {
-    case "run.start":
-      return "run.start";
-    case "run.end":
-      if (event.data.status === "completed") return "run.ok";
-      if (event.data.status === "failed") return "run.fail";
-      return "run.abort";
-    case "user.prompt":
-      return "prompt";
-    case "plan.update":
-      return "plan.upd";
-    case "reasoning.summary":
-      return "reason";
-    case "usage.update":
-      return "usage.upd";
-    case "tool.delta":
-      return "tool.call";
-    case "tool.pre":
-      return "tool.call";
-    case "tool.post":
-      return "tool.ok";
-    case "tool.failure":
-      return "tool.fail";
-    case "subagent.start":
-      return "sub.start";
-    case "subagent.stop":
-      return "sub.stop";
-    case "permission.request":
-      return "perm.req";
-    case "permission.decision":
-      return `perm.${event.data.decision_type}`;
-    case "stop.request":
-      return "stop.req";
-    case "stop.decision":
-      return `stop.${event.data.decision_type}`;
-    case "session.start":
-      return "sess.start";
-    case "session.end":
-      return "sess.end";
-    case "notification":
-      return "notify";
-    case "runtime.error":
-      return "error";
-    case "thread.status":
-      return "thread";
-    case "turn.diff":
-      return "diff";
-    case "server.request.resolved":
-      return "req.done";
-    case "web.search":
-      return "web.search";
-    case "review.status":
-      return "review";
-    case "image.view":
-      return "image";
-    case "context.compaction":
-      return "compact";
-    case "mcp.progress":
-      return "mcp.prog";
-    case "terminal.input":
-      return "term.in";
-    case "skills.changed":
-      return "skills";
-    case "skills.loaded":
-      return "skills";
-    case "compact.pre":
-      return "compact";
-    case "setup":
-      return "setup";
-    case "unknown.hook":
-      return "unknown";
-    case "todo.add":
-      return "todo.add";
-    case "todo.update":
-      return "todo.upd";
-    case "todo.done":
-      return "todo.done";
-    case "agent.message":
-      return "agent.msg";
-    case "teammate.idle":
-      return "tm.idle";
-    case "task.completed":
-      return "task.ok";
-    case "config.change":
-      return "cfg.chg";
-    default:
-      return "event";
-  }
+function stripMarkdownInline(text) {
+  return text.replace(/#{1,6}\s+/g, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/`(.+?)`/g, "$1").replace(/~~(.+?)~~/g, "$1");
 }
-function eventLabel(event) {
-  if (isDefaultRenderKind(event.kind)) return "Event";
-  switch (event.kind) {
-    case "run.start":
-      return "Run Start";
-    case "run.end":
-      if (event.data.status === "completed") return "Run OK";
-      if (event.data.status === "failed") return "Run Fail";
-      return "Run Abort";
-    case "user.prompt":
-      return "User Prompt";
-    case "plan.update":
-      return "Plan Update";
-    case "reasoning.summary":
-      return "Reasoning";
-    case "usage.update":
-      return "Usage Update";
-    case "tool.delta":
-      return "Tool Call";
-    case "tool.pre":
-      return "Tool Call";
-    case "tool.post":
-      return "Tool OK";
-    case "tool.failure":
-      return "Tool Fail";
-    case "subagent.start":
-      return "Sub Start";
-    case "subagent.stop":
-      return "Sub Stop";
-    case "permission.request":
-      return "Perm Request";
-    case "permission.decision":
-      switch (event.data.decision_type) {
-        case "allow":
-          return "Perm Allow";
-        case "deny":
-          return "Perm Deny";
-        case "ask":
-          return "Perm Ask";
-        case "no_opinion":
-          return "Perm Skip";
-        default:
-          return "Perm Decision";
-      }
-    case "stop.request":
-      return "Stop Request";
-    case "stop.decision":
-      switch (event.data.decision_type) {
-        case "block":
-          return "Stop Block";
-        case "allow":
-          return "Stop Allow";
-        case "no_opinion":
-          return "Stop Skip";
-        default:
-          return "Stop Decision";
-      }
-    case "session.start":
-      return "Sess Start";
-    case "session.end":
-      return "Sess End";
-    case "notification":
-      return "Notify";
-    case "runtime.error":
-      return "Error";
-    case "thread.status":
-      return "Thread";
-    case "turn.diff":
-      return "Diff";
-    case "server.request.resolved":
-      return "Request";
-    case "web.search":
-      return "Web Search";
-    case "review.status":
-      return "Review";
-    case "image.view":
-      return "Image";
-    case "context.compaction":
-      return "Compaction";
-    case "mcp.progress":
-      return "MCP Progress";
-    case "terminal.input":
-      return "Terminal In";
-    case "skills.changed":
-      return "Skills";
-    case "skills.loaded":
-      return "Skills";
-    case "compact.pre":
-      return "Compact";
-    case "setup":
-      return "Setup";
-    case "unknown.hook":
-      return "Unknown";
-    case "todo.add":
-      return "Todo Add";
-    case "todo.update":
-      return "Todo Update";
-    case "todo.done":
-      return "Todo Done";
-    case "agent.message":
-      return "Agent Msg";
-    case "teammate.idle":
-      return "Team Idle";
-    case "task.completed":
-      return "Task OK";
-    case "config.change":
-      return "Config Chg";
-    default:
-      return "Event";
+function firstSentence(text) {
+  const nlIdx = text.indexOf("\n");
+  const sentIdx = text.indexOf(". ");
+  const nlEnd = nlIdx === -1 ? Infinity : nlIdx;
+  const sentEnd = sentIdx === -1 ? Infinity : sentIdx + 1;
+  const end = Math.min(nlEnd, sentEnd, text.length);
+  return text.slice(0, end).trim();
+}
+function resolveDisplayName(toolName) {
+  const parsed = parseToolName(toolName);
+  if (parsed.isMcp && parsed.mcpServer && parsed.mcpAction) {
+    const friendlyServer = extractFriendlyServerName(parsed.mcpServer);
+    return `[${friendlyServer}] ${parsed.mcpAction}`;
   }
+  return toolName;
 }
 var PATH_TOOLS = /* @__PURE__ */ new Set(["Read", "Write", "Edit", "Glob", "Grep"]);
 function withMcpServerContext(parsed, primaryInput) {
@@ -5520,89 +5308,6 @@ function formatToolSummary(toolName, toolInput, errorSuffix) {
     ]
   };
 }
-function eventSummary(event) {
-  const harness = harnessSummary(event);
-  if (harness) return harness;
-  switch (event.kind) {
-    case "tool.delta":
-    case "tool.pre":
-    case "tool.post":
-      return formatToolSummary(event.data.tool_name, event.data.tool_input);
-    case "permission.request":
-      return formatPermissionSummary(event);
-    case "tool.failure":
-      return formatToolSummary(
-        event.data.tool_name,
-        event.data.tool_input,
-        event.data.error
-      );
-    case "subagent.start":
-    case "subagent.stop": {
-      const text = compactText(
-        event.data.description?.trim() || `id:${event.data.agent_id}`,
-        200
-      );
-      return { text, segments: [{ text, role: "target" }] };
-    }
-    case "agent.message": {
-      const text = eventSummaryText(event);
-      return { text, segments: [{ text, role: "plain" }] };
-    }
-    case "setup":
-    case "session.start":
-    case "session.end":
-    case "run.start":
-    case "run.end":
-    case "user.prompt":
-    case "plan.update":
-    case "reasoning.summary":
-    case "usage.update":
-    case "permission.decision":
-    case "permission.denied":
-    case "stop.request":
-    case "stop.decision":
-    case "stop.failure":
-    case "notification":
-    case "runtime.error":
-    case "thread.status":
-    case "turn.diff":
-    case "server.request.resolved":
-    case "web.search":
-    case "review.status":
-    case "image.view":
-    case "context.compaction":
-    case "mcp.progress":
-    case "terminal.input":
-    case "skills.changed":
-    case "skills.loaded":
-    case "compact.pre":
-    case "compact.post":
-    case "unknown.hook":
-    case "todo.add":
-    case "todo.update":
-    case "todo.done":
-    case "teammate.idle":
-    case "task.created":
-    case "task.completed":
-    case "config.change":
-    case "cwd.changed":
-    case "file.changed":
-    case "elicitation.request":
-    case "elicitation.result":
-    case "channel.permission.relayed":
-    case "channel.permission.resolved":
-    case "channel.question.relayed":
-    case "channel.question.resolved":
-    case "channel.chat.inbound":
-    case "channel.chat.outbound":
-    case "gateway.function.invoked":
-    case "gateway.function.completed":
-    case "gateway.function.failed": {
-      const text = eventSummaryText(event);
-      return { text, segments: [{ text, role: "target" }] };
-    }
-  }
-}
 function formatPermissionSummary(event) {
   const base = formatToolSummary(event.data.tool_name, event.data.tool_input);
   const host = event.data.network_context?.host;
@@ -5617,369 +5322,619 @@ function formatPermissionSummary(event) {
     segments: [...base.segments, { text: suffix, role: "target" }]
   };
 }
-function stripMarkdownInline(text) {
-  return text.replace(/#{1,6}\s+/g, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/`(.+?)`/g, "$1").replace(/~~(.+?)~~/g, "$1");
+function formatRunEndSummary(event) {
+  const toolText = `${event.data.counters.tool_uses} tool${event.data.counters.tool_uses === 1 ? "" : "s"}`;
+  const failureCount = event.data.counters.tool_failures;
+  if (failureCount > 0) {
+    return `${event.data.status} \xB7 ${toolText}, ${failureCount} failure${failureCount === 1 ? "" : "s"}`;
+  }
+  return `${event.data.status} \xB7 ${toolText}`;
 }
-function firstSentence(text) {
-  const nlIdx = text.indexOf("\n");
-  const sentIdx = text.indexOf(". ");
-  const nlEnd = nlIdx === -1 ? Infinity : nlIdx;
-  const sentEnd = sentIdx === -1 ? Infinity : sentIdx + 1;
-  const end = Math.min(nlEnd, sentEnd, text.length);
-  return text.slice(0, end).trim();
+function harnessSummary(event) {
+  const title = event.display?.title?.trim();
+  if (!title) return void 0;
+  const text = compactText(title, 200);
+  return { text, segments: [{ text, role: "target" }] };
 }
-function eventSummaryText(event) {
-  switch (event.kind) {
-    case "run.start":
-      return compactText(
-        event.data.trigger.prompt_preview || "interactive",
-        200
-      );
-    case "run.end":
-      return compactText(formatRunEndSummary(event), 200);
-    case "user.prompt":
-      return compactText(event.data.prompt, 200);
-    case "plan.update": {
-      if (event.data.explanation) {
-        return compactText(event.data.explanation, 200);
-      }
-      if (event.data.plan && event.data.plan.length > 0) {
-        const completed = event.data.plan.filter(
-          (step) => step.status === "completed"
-        ).length;
-        return compactText(`${completed}/${event.data.plan.length} steps`, 200);
-      }
-      return compactText(event.data.delta || "plan updated", 200);
-    }
-    case "reasoning.summary":
-      return compactText(
-        firstSentence(stripMarkdownInline(event.data.message)),
-        200
-      );
-    case "usage.update": {
-      const total = event.data.usage?.total;
-      const delta = event.data.delta?.total;
-      if (typeof total === "number" && typeof delta === "number") {
-        return compactText(
-          `${total.toLocaleString()} total (+${delta.toLocaleString()})`,
-          200
-        );
-      }
-      if (typeof total === "number") {
-        return compactText(`${total.toLocaleString()} total`, 200);
-      }
-      return compactText("usage updated", 200);
-    }
-    case "permission.decision": {
-      const detail = event.data.decision_type === "deny" ? event.data.message || event.data.reason : event.data.reason;
-      return compactText(detail || event.data.decision_type, 200);
-    }
-    case "stop.request":
-      return compactText(
-        event.data.stop_hook_active ? "Stop hook active" : "Stop hook inactive",
-        200
-      );
-    case "stop.decision":
-      return compactText(event.data.reason || event.data.decision_type, 200);
-    case "session.start":
-      return compactText(event.data.source, 200);
-    case "session.end":
-      return compactText(event.data.reason, 200);
-    case "notification":
-      return compactText(stripMarkdownInline(event.data.message), 200);
-    case "runtime.error":
-      return compactText(stripMarkdownInline(event.data.message), 200);
-    case "thread.status":
-      return compactText(event.data.message, 200);
-    case "turn.diff":
-      return compactText(event.data.message, 200);
-    case "server.request.resolved":
-      return compactText(event.data.message, 200);
-    case "web.search":
-      return compactText(event.data.message, 200);
-    case "review.status":
-      return compactText(event.data.message, 200);
-    case "image.view":
-      return compactText(event.data.message, 200);
-    case "context.compaction":
-      return compactText(event.data.message, 200);
-    case "mcp.progress":
-      return compactText(event.data.message, 200);
-    case "terminal.input":
-      return compactText(event.data.message, 200);
-    case "skills.changed":
-    case "skills.loaded":
-      return compactText(event.data.message, 200);
-    case "compact.pre":
-      return compactText(event.data.trigger, 200);
-    case "setup":
-      return compactText(event.data.trigger, 200);
-    case "unknown.hook":
-      return compactText(event.data.hook_event_name, 200);
-    case "todo.add":
-      return compactText(
-        `${event.data.priority?.toUpperCase() ?? "P1"} ${event.data.text}`,
-        200
-      );
-    case "todo.update": {
-      const patchFields = Object.keys(event.data.patch);
-      return compactText(
-        `${event.data.todo_id} ${patchFields.length > 0 ? patchFields.join(",") : "update"}`,
-        200
-      );
-    }
-    case "todo.done":
-      return compactText(
-        `${event.data.todo_id} ${event.data.reason || "done"}`,
-        200
-      );
-    case "agent.message":
-      return compactText(
-        firstSentence(stripMarkdownInline(event.data.message)),
-        200
-      );
-    case "teammate.idle":
-      return compactText(
-        `${event.data.teammate_name} idle in ${event.data.team_name}`,
-        200
-      );
-    case "task.created":
-    case "task.completed":
-      return compactText(event.data.task_subject, 200);
-    case "config.change":
-      return compactText(
-        `${event.data.source}${event.data.file_path ? ` ${event.data.file_path}` : ""}`,
-        200
-      );
-    case "cwd.changed":
-      return compactText(`cwd \u2192 ${event.data.cwd}`, 200);
-    case "file.changed":
-      return compactText(`changed ${event.data.file_path}`, 200);
-    case "stop.failure":
-      return compactText(
-        `${event.data.error_type}${event.data.error_message ? `: ${event.data.error_message}` : ""}`,
-        200
-      );
-    case "permission.denied":
-      return compactText(
-        `${event.data.tool_name}${event.data.reason ? `: ${event.data.reason}` : ""}`,
-        200
-      );
-    case "elicitation.request":
-      return compactText(`elicitation from ${event.data.mcp_server}`, 200);
-    case "elicitation.result":
-      return compactText(
-        `${event.data.mcp_server} \u2192 ${event.data.action}`,
-        200
-      );
-    case "channel.permission.relayed":
-      return compactText(
-        `${event.data.channel_name}: ${event.data.tool_name} (${event.data.channel_request_id})`,
-        200
-      );
-    case "channel.permission.resolved":
-      return compactText(
-        `${event.data.channel_name} ${event.data.source} ${event.data.tool_name}`,
-        200
-      );
-    case "channel.question.relayed":
-      return compactText(
-        `${event.data.channel_name}: ${event.data.title} (${event.data.channel_request_id})`,
-        200
-      );
-    case "channel.question.resolved":
-      return compactText(
-        `${event.data.channel_name || event.data.source} ${event.data.source} ${event.data.title}`,
-        200
-      );
-    case "channel.chat.inbound":
-      return compactText(
-        `${event.data.channel_name}: ${event.data.content}`,
-        200
-      );
-    case "channel.chat.outbound":
-      return compactText(
-        `${event.data.channel_name} \u2192 ${event.data.target_peer_id}: ${event.data.content}`,
-        200
-      );
-    case "gateway.function.invoked":
-      return compactText(
-        `fn invoked: ${event.data.function_name} (${event.data.caller_kind})`,
-        200
-      );
-    case "gateway.function.completed":
-      return compactText(
-        `fn ok: ${event.data.function_name} ${event.data.duration_ms}ms`,
-        200
-      );
-    case "gateway.function.failed":
-      return compactText(
-        `fn ${event.data.reason}: ${event.data.function_name} \u2014 ${event.data.error_message}`,
-        200
-      );
-    case "compact.post":
-      return compactText(`compacted (${event.data.trigger})`, 200);
-    case "tool.pre":
-    case "tool.delta":
-    case "tool.post":
-    case "tool.failure":
-    case "permission.request":
-    case "subagent.start":
-    case "subagent.stop":
-      return compactText("event", 200);
+function postOutcome(postEvent) {
+  if (postEvent.kind === "tool.failure") {
+    return summarizeToolResult(
+      postEvent.data.tool_name,
+      postEvent.data.tool_input,
+      void 0,
+      postEvent.data.error
+    );
   }
-}
-function formatRunEndSummary(event) {
-  const toolText = `${event.data.counters.tool_uses} tool${event.data.counters.tool_uses === 1 ? "" : "s"}`;
-  const failureCount = event.data.counters.tool_failures;
-  if (failureCount > 0) {
-    return `${event.data.status} \xB7 ${toolText}, ${failureCount} failure${failureCount === 1 ? "" : "s"}`;
+  if (postEvent.kind === "tool.post") {
+    return summarizeToolResult(
+      postEvent.data.tool_name,
+      postEvent.data.tool_input,
+      postEvent.data.tool_response
+    );
   }
-  return `${event.data.status} \xB7 ${toolText}`;
+  return void 0;
 }
-function expansionForEvent(event) {
-  switch (event.kind) {
-    case "tool.pre":
-    case "tool.delta":
-      return JSON.stringify(
-        { tool: event.data.tool_name, args: event.data.tool_input },
-        null,
-        2
-      );
-    case "tool.post":
-      return JSON.stringify(
-        {
-          tool: event.data.tool_name,
-          args: event.data.tool_input,
-          result: event.data.tool_response
-        },
-        null,
-        2
-      );
-    case "tool.failure":
-      return JSON.stringify(
-        {
-          tool: event.data.tool_name,
-          args: event.data.tool_input,
-          error: event.data.error,
-          interrupt: event.data.is_interrupt
-        },
-        null,
-        2
-      );
-    case "permission.request":
-      return JSON.stringify(
-        {
-          tool: event.data.tool_name,
-          args: event.data.tool_input,
-          suggestions: event.data.permission_suggestions
-        },
-        null,
-        2
+function plainSummary(text) {
+  const compact = compactText(text, 200);
+  return { text: compact, segments: [{ text: compact, role: "target" }] };
+}
+function dataExpansion(event) {
+  return JSON.stringify(event.data, null, 2);
+}
+function rawOrDataExpansion(event) {
+  return JSON.stringify(event.raw ?? event.data, null, 2);
+}
+function defaultRenderer(summarize2) {
+  return {
+    operation: () => "event",
+    label: () => "Event",
+    detail: () => "\u2500",
+    summary: (event) => plainSummary(summarize2(event)),
+    expansion: rawOrDataExpansion
+  };
+}
+var sessionStart = {
+  operation: () => "sess.start",
+  label: () => "Sess Start",
+  detail: (event) => event.data.source,
+  summary: (event) => plainSummary(event.data.source),
+  expansion: rawOrDataExpansion
+};
+var sessionEnd = {
+  operation: () => "sess.end",
+  label: () => "Sess End",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.reason),
+  expansion: rawOrDataExpansion
+};
+var runStart = {
+  operation: () => "run.start",
+  label: () => "Run Start",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.trigger.prompt_preview || "interactive"),
+  expansion: rawOrDataExpansion
+};
+var runEnd = {
+  operation: (event) => {
+    if (event.data.status === "completed") return "run.ok";
+    if (event.data.status === "failed") return "run.fail";
+    return "run.abort";
+  },
+  label: (event) => {
+    if (event.data.status === "completed") return "Run OK";
+    if (event.data.status === "failed") return "Run Fail";
+    return "Run Abort";
+  },
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(formatRunEndSummary(event)),
+  expansion: dataExpansion,
+  isError: (event) => event.data.status !== "completed"
+};
+var userPrompt = {
+  operation: () => "prompt",
+  label: () => "User Prompt",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.prompt),
+  expansion: rawOrDataExpansion
+};
+var planUpdate = {
+  operation: () => "plan.upd",
+  label: () => "Plan Update",
+  detail: () => "plan",
+  summary: (event) => {
+    if (event.data.explanation) return plainSummary(event.data.explanation);
+    if (event.data.plan && event.data.plan.length > 0) {
+      const completed = event.data.plan.filter(
+        (step) => step.status === "completed"
+      ).length;
+      return plainSummary(`${completed}/${event.data.plan.length} steps`);
+    }
+    return plainSummary(event.data.delta || "plan updated");
+  },
+  expansion: dataExpansion
+};
+var reasoningSummary = {
+  operation: () => "reason",
+  label: () => "Reasoning",
+  detail: () => "summary",
+  summary: (event) => plainSummary(firstSentence(stripMarkdownInline(event.data.message))),
+  expansion: dataExpansion
+};
+var usageUpdate = {
+  operation: () => "usage.upd",
+  label: () => "Usage Update",
+  detail: () => "tokens",
+  summary: (event) => {
+    const total = event.data.usage?.total;
+    const delta = event.data.delta?.total;
+    if (typeof total === "number" && typeof delta === "number") {
+      return plainSummary(
+        `${total.toLocaleString()} total (+${delta.toLocaleString()})`
       );
-    case "subagent.stop":
-    case "run.end":
-    case "plan.update":
-    case "reasoning.summary":
-    case "usage.update":
-    case "runtime.error":
-    case "thread.status":
-    case "turn.diff":
-    case "server.request.resolved":
-    case "web.search":
-    case "review.status":
-    case "image.view":
-    case "context.compaction":
-    case "mcp.progress":
-    case "terminal.input":
-    case "skills.changed":
-    case "skills.loaded":
-      return JSON.stringify(event.data, null, 2);
-    case "setup":
-    case "session.start":
-    case "session.end":
-    case "run.start":
-    case "user.prompt":
-    case "permission.decision":
-    case "permission.denied":
-    case "stop.request":
-    case "stop.decision":
-    case "stop.failure":
-    case "notification":
-    case "subagent.start":
-    case "compact.pre":
-    case "compact.post":
-    case "unknown.hook":
-    case "todo.add":
-    case "todo.update":
-    case "todo.done":
-    case "agent.message":
-    case "teammate.idle":
-    case "task.created":
-    case "task.completed":
-    case "config.change":
-    case "cwd.changed":
-    case "file.changed":
-    case "elicitation.request":
-    case "elicitation.result":
-    case "channel.permission.relayed":
-    case "channel.permission.resolved":
-    case "channel.question.relayed":
-    case "channel.question.resolved":
-    case "channel.chat.inbound":
-    case "channel.chat.outbound":
-    case "gateway.function.invoked":
-    case "gateway.function.completed":
-    case "gateway.function.failed":
-      return JSON.stringify(event.raw ?? event.data, null, 2);
-  }
+    }
+    if (typeof total === "number") {
+      return plainSummary(`${total.toLocaleString()} total`);
+    }
+    return plainSummary("usage updated");
+  },
+  expansion: dataExpansion
+};
+var toolDelta = {
+  operation: () => "tool.call",
+  label: () => "Tool Call",
+  detail: (event) => resolveDisplayName(event.data.tool_name),
+  summary: (event) => formatToolSummary(event.data.tool_name, event.data.tool_input),
+  expansion: (event) => JSON.stringify(
+    { tool: event.data.tool_name, args: event.data.tool_input },
+    null,
+    2
+  )
+};
+var toolPre = {
+  operation: () => "tool.call",
+  label: () => "Tool Call",
+  detail: (event) => resolveDisplayName(event.data.tool_name),
+  summary: (event) => formatToolSummary(event.data.tool_name, event.data.tool_input),
+  expansion: (event) => JSON.stringify(
+    { tool: event.data.tool_name, args: event.data.tool_input },
+    null,
+    2
+  )
+};
+var toolPost = {
+  operation: () => "tool.ok",
+  label: () => "Tool OK",
+  detail: (event) => resolveDisplayName(event.data.tool_name),
+  summary: (event) => formatToolSummary(event.data.tool_name, event.data.tool_input),
+  expansion: (event) => JSON.stringify(
+    {
+      tool: event.data.tool_name,
+      args: event.data.tool_input,
+      result: event.data.tool_response
+    },
+    null,
+    2
+  )
+};
+var toolFailure = {
+  operation: () => "tool.fail",
+  label: () => "Tool Fail",
+  detail: (event) => resolveDisplayName(event.data.tool_name),
+  summary: (event) => formatToolSummary(
+    event.data.tool_name,
+    event.data.tool_input,
+    event.data.error
+  ),
+  expansion: (event) => JSON.stringify(
+    {
+      tool: event.data.tool_name,
+      args: event.data.tool_input,
+      error: event.data.error,
+      interrupt: event.data.is_interrupt
+    },
+    null,
+    2
+  ),
+  isError: () => true
+};
+var permissionRequest = {
+  operation: () => "perm.req",
+  label: () => "Perm Request",
+  detail: (event) => resolveDisplayName(event.data.tool_name),
+  summary: (event) => formatPermissionSummary(event),
+  expansion: (event) => JSON.stringify(
+    {
+      tool: event.data.tool_name,
+      args: event.data.tool_input,
+      suggestions: event.data.permission_suggestions
+    },
+    null,
+    2
+  )
+};
+var permissionDecision = {
+  operation: (event) => `perm.${event.data.decision_type}`,
+  label: (event) => {
+    switch (event.data.decision_type) {
+      case "allow":
+        return "Perm Allow";
+      case "deny":
+        return "Perm Deny";
+      case "ask":
+        return "Perm Ask";
+      case "no_opinion":
+        return "Perm Skip";
+      default:
+        return "Perm Decision";
+    }
+  },
+  detail: () => "\u2500",
+  summary: (event) => {
+    const detail = event.data.decision_type === "deny" ? event.data.message || event.data.reason : event.data.reason;
+    return plainSummary(detail || event.data.decision_type);
+  },
+  expansion: rawOrDataExpansion,
+  isError: (event) => event.data.decision_type === "deny"
+};
+var stopRequest = {
+  operation: () => "stop.req",
+  label: () => "Stop Request",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(
+    event.data.stop_hook_active ? "Stop hook active" : "Stop hook inactive"
+  ),
+  expansion: rawOrDataExpansion
+};
+var stopDecision = {
+  operation: (event) => `stop.${event.data.decision_type}`,
+  label: (event) => {
+    switch (event.data.decision_type) {
+      case "block":
+        return "Stop Block";
+      case "allow":
+        return "Stop Allow";
+      case "no_opinion":
+        return "Stop Skip";
+      default:
+        return "Stop Decision";
+    }
+  },
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.reason || event.data.decision_type),
+  expansion: rawOrDataExpansion,
+  isError: (event) => event.data.decision_type === "block"
+};
+var subagentStart = {
+  operation: () => "sub.start",
+  label: () => "Sub Start",
+  detail: (event) => event.data.agent_type,
+  summary: (event) => {
+    const text = compactText(
+      event.data.description?.trim() || `id:${event.data.agent_id}`,
+      200
+    );
+    return { text, segments: [{ text, role: "target" }] };
+  },
+  expansion: rawOrDataExpansion
+};
+var subagentStop = {
+  operation: () => "sub.stop",
+  label: () => "Sub Stop",
+  detail: (event) => event.data.agent_type,
+  summary: (event) => {
+    const text = compactText(
+      event.data.description?.trim() || `id:${event.data.agent_id}`,
+      200
+    );
+    return { text, segments: [{ text, role: "target" }] };
+  },
+  expansion: dataExpansion
+};
+var notification = {
+  operation: () => "notify",
+  label: () => "Notify",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(stripMarkdownInline(event.data.message)),
+  expansion: rawOrDataExpansion
+};
+var runtimeError = {
+  operation: () => "error",
+  label: () => "Error",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(stripMarkdownInline(event.data.message)),
+  expansion: dataExpansion,
+  isError: () => true
+};
+var threadStatus = {
+  operation: () => "thread",
+  label: () => "Thread",
+  detail: (event) => event.data.status_type ?? "status",
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var turnDiff = {
+  operation: () => "diff",
+  label: () => "Diff",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var serverRequestResolved = {
+  operation: () => "req.done",
+  label: () => "Request",
+  detail: (event) => event.data.request_id ?? "request",
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var webSearch = {
+  operation: () => "web.search",
+  label: () => "Web Search",
+  detail: (event) => event.data.action_type ?? event.data.phase,
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var reviewStatus = {
+  operation: () => "review",
+  label: () => "Review",
+  detail: (event) => event.data.phase,
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var imageView = {
+  operation: () => "image",
+  label: () => "Image",
+  detail: (event) => event.data.path ?? "image",
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var contextCompaction = {
+  operation: () => "compact",
+  label: () => "Compaction",
+  detail: (event) => event.data.phase,
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var mcpProgress = {
+  operation: () => "mcp.prog",
+  label: () => "MCP Progress",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var terminalInput = {
+  operation: () => "term.in",
+  label: () => "Terminal In",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var skillsChanged = {
+  operation: () => "skills",
+  label: () => "Skills",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var skillsLoaded = {
+  operation: () => "skills",
+  label: () => "Skills",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.message),
+  expansion: dataExpansion
+};
+var compactPre = {
+  operation: () => "compact",
+  label: () => "Compact",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.trigger),
+  expansion: dataExpansion
+};
+var setup = {
+  operation: () => "setup",
+  label: () => "Setup",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.trigger),
+  expansion: rawOrDataExpansion
+};
+var unknownHook = {
+  operation: () => "unknown",
+  label: () => "Unknown",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.hook_event_name),
+  expansion: rawOrDataExpansion
+};
+var todoAdd = {
+  operation: () => "todo.add",
+  label: () => "Todo Add",
+  detail: (event) => (event.data.priority ?? "p1").toUpperCase(),
+  summary: (event) => plainSummary(
+    `${event.data.priority?.toUpperCase() ?? "P1"} ${event.data.text}`
+  ),
+  expansion: rawOrDataExpansion
+};
+var todoUpdate = {
+  operation: () => "todo.upd",
+  label: () => "Todo Update",
+  detail: (event) => event.data.todo_id,
+  summary: (event) => {
+    const patchFields = Object.keys(event.data.patch);
+    return plainSummary(
+      `${event.data.todo_id} ${patchFields.length > 0 ? patchFields.join(",") : "update"}`
+    );
+  },
+  expansion: rawOrDataExpansion
+};
+var todoDone = {
+  operation: () => "todo.done",
+  label: () => "Todo Done",
+  detail: (event) => event.data.todo_id,
+  summary: (event) => plainSummary(`${event.data.todo_id} ${event.data.reason || "done"}`),
+  expansion: rawOrDataExpansion
+};
+var agentMessage = {
+  operation: () => "agent.msg",
+  label: () => "Agent Msg",
+  detail: () => "\u2500",
+  summary: (event) => {
+    const text = compactText(
+      firstSentence(stripMarkdownInline(event.data.message)),
+      200
+    );
+    return { text, segments: [{ text, role: "plain" }] };
+  },
+  expansion: rawOrDataExpansion
+};
+var teammateIdle = {
+  operation: () => "tm.idle",
+  label: () => "Team Idle",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(`${event.data.teammate_name} idle in ${event.data.team_name}`),
+  expansion: rawOrDataExpansion
+};
+var taskCompleted = {
+  operation: () => "task.ok",
+  label: () => "Task OK",
+  detail: () => "\u2500",
+  summary: (event) => plainSummary(event.data.task_subject),
+  expansion: rawOrDataExpansion
+};
+var configChange = {
+  operation: () => "cfg.chg",
+  label: () => "Config Chg",
+  detail: (event) => event.data.source,
+  summary: (event) => plainSummary(
+    `${event.data.source}${event.data.file_path ? ` ${event.data.file_path}` : ""}`
+  ),
+  expansion: rawOrDataExpansion
+};
+var compactPost = defaultRenderer(
+  (event) => `compacted (${event.data.trigger})`
+);
+var taskCreated = defaultRenderer(
+  (event) => event.data.task_subject
+);
+var cwdChanged = defaultRenderer(
+  (event) => `cwd \u2192 ${event.data.cwd}`
+);
+var fileChanged = defaultRenderer(
+  (event) => `changed ${event.data.file_path}`
+);
+var stopFailure = defaultRenderer(
+  (event) => `${event.data.error_type}${event.data.error_message ? `: ${event.data.error_message}` : ""}`
+);
+var permissionDenied = defaultRenderer(
+  (event) => `${event.data.tool_name}${event.data.reason ? `: ${event.data.reason}` : ""}`
+);
+var elicitationRequest = defaultRenderer((event) => `elicitation from ${event.data.mcp_server}`);
+var elicitationResult = defaultRenderer(
+  (event) => `${event.data.mcp_server} \u2192 ${event.data.action}`
+);
+var channelPermissionRelayed = defaultRenderer(
+  (event) => `${event.data.channel_name}: ${event.data.tool_name} (${event.data.channel_request_id})`
+);
+var channelPermissionResolved = defaultRenderer(
+  (event) => `${event.data.channel_name} ${event.data.source} ${event.data.tool_name}`
+);
+var channelQuestionRelayed = defaultRenderer(
+  (event) => `${event.data.channel_name}: ${event.data.title} (${event.data.channel_request_id})`
+);
+var channelQuestionResolved = defaultRenderer(
+  (event) => `${event.data.channel_name || event.data.source} ${event.data.source} ${event.data.title}`
+);
+var channelChatInbound = defaultRenderer((event) => `${event.data.channel_name}: ${event.data.content}`);
+var channelChatOutbound = defaultRenderer(
+  (event) => `${event.data.channel_name} \u2192 ${event.data.target_peer_id}: ${event.data.content}`
+);
+var gatewayFunctionInvoked = defaultRenderer(
+  (event) => `fn invoked: ${event.data.function_name} (${event.data.caller_kind})`
+);
+var gatewayFunctionCompleted = defaultRenderer(
+  (event) => `fn ok: ${event.data.function_name} ${event.data.duration_ms}ms`
+);
+var gatewayFunctionFailed = defaultRenderer(
+  (event) => `fn ${event.data.reason}: ${event.data.function_name} \u2014 ${event.data.error_message}`
+);
+var RENDERERS = {
+  "session.start": sessionStart,
+  "session.end": sessionEnd,
+  "run.start": runStart,
+  "run.end": runEnd,
+  "user.prompt": userPrompt,
+  "plan.update": planUpdate,
+  "reasoning.summary": reasoningSummary,
+  "usage.update": usageUpdate,
+  "tool.delta": toolDelta,
+  "tool.pre": toolPre,
+  "tool.post": toolPost,
+  "tool.failure": toolFailure,
+  "permission.request": permissionRequest,
+  "permission.decision": permissionDecision,
+  "stop.request": stopRequest,
+  "stop.decision": stopDecision,
+  "subagent.start": subagentStart,
+  "subagent.stop": subagentStop,
+  notification,
+  "runtime.error": runtimeError,
+  "thread.status": threadStatus,
+  "turn.diff": turnDiff,
+  "server.request.resolved": serverRequestResolved,
+  "web.search": webSearch,
+  "review.status": reviewStatus,
+  "image.view": imageView,
+  "context.compaction": contextCompaction,
+  "mcp.progress": mcpProgress,
+  "terminal.input": terminalInput,
+  "skills.changed": skillsChanged,
+  "skills.loaded": skillsLoaded,
+  "compact.pre": compactPre,
+  "compact.post": compactPost,
+  setup,
+  "unknown.hook": unknownHook,
+  "todo.add": todoAdd,
+  "todo.update": todoUpdate,
+  "todo.done": todoDone,
+  "agent.message": agentMessage,
+  "teammate.idle": teammateIdle,
+  "task.created": taskCreated,
+  "task.completed": taskCompleted,
+  "config.change": configChange,
+  "cwd.changed": cwdChanged,
+  "file.changed": fileChanged,
+  "stop.failure": stopFailure,
+  "permission.denied": permissionDenied,
+  "elicitation.request": elicitationRequest,
+  "elicitation.result": elicitationResult,
+  "channel.permission.relayed": channelPermissionRelayed,
+  "channel.permission.resolved": channelPermissionResolved,
+  "channel.question.relayed": channelQuestionRelayed,
+  "channel.question.resolved": channelQuestionResolved,
+  "channel.chat.inbound": channelChatInbound,
+  "channel.chat.outbound": channelChatOutbound,
+  "gateway.function.invoked": gatewayFunctionInvoked,
+  "gateway.function.completed": gatewayFunctionCompleted,
+  "gateway.function.failed": gatewayFunctionFailed
+};
+function rendererFor(event) {
+  return RENDERERS[event.kind];
+}
+function eventOperation(event) {
+  return rendererFor(event).operation(event);
+}
+function eventLabel(event) {
+  return rendererFor(event).label(event);
+}
+function eventSummary(event) {
+  const harness = harnessSummary(event);
+  if (harness) return harness;
+  return rendererFor(event).summary(event);
+}
+function expansionForEvent(event) {
+  return rendererFor(event).expansion(event);
 }
 function isEventError(event) {
   if (event.level === "error") return true;
-  if (event.kind === "tool.failure") return true;
-  if (event.kind === "runtime.error") return true;
-  if (event.kind === "run.end") return event.data.status !== "completed";
-  if (event.kind === "permission.decision" && event.data.decision_type === "deny") {
-    return true;
-  }
-  if (event.kind === "stop.decision" && event.data.decision_type === "block") {
-    return true;
-  }
-  return false;
+  const renderer = rendererFor(event);
+  return renderer.isError?.(event) ?? false;
 }
 function isEventExpandable(event) {
   void event;
   return true;
 }
-var VERBOSE_ONLY_KINDS = /* @__PURE__ */ new Set([
-  "session.start",
-  "session.end",
-  "run.start",
-  "run.end",
-  "unknown.hook",
-  "compact.pre",
-  "config.change",
-  "turn.diff",
-  "usage.update",
-  "reasoning.summary"
-]);
-function mergedEventOperation(event, postEvent) {
-  if (!postEvent) return eventOperation(event);
-  if (postEvent.kind === "tool.failure") return "tool.fail";
-  if (postEvent.kind === "tool.post") return "tool.ok";
-  return eventOperation(event);
-}
-function mergedEventLabel(event, postEvent) {
-  if (!postEvent) return eventLabel(event);
-  if (postEvent.kind === "tool.failure") return "Tool Fail";
-  if (postEvent.kind === "tool.post") return "Tool OK";
-  return eventLabel(event);
-}
-function mergedEventSummary(event, postEvent) {
-  if (!postEvent) return eventSummary(event);
-  if (event.kind !== "tool.pre" && event.kind !== "permission.request") {
-    return eventSummary(event);
-  }
+var toolPairOk = {
+  operation: () => "tool.ok",
+  label: () => "Tool OK",
+  summary: (pre, post) => buildMergedToolSummary(pre, post)
+};
+var toolPairFail = {
+  operation: () => "tool.fail",
+  label: () => "Tool Fail",
+  summary: (pre, post) => buildMergedToolSummary(pre, post)
+};
+var TOOL_PAIRS = {
+  "tool.post": toolPairOk,
+  "tool.failure": toolPairFail
+};
+function buildMergedToolSummary(event, postEvent) {
   const harness = harnessSummary(event) ?? harnessSummary(postEvent);
   if (harness) {
     return {
@@ -6006,279 +5961,74 @@ function mergedEventSummary(event, postEvent) {
       void 0,
       postEvent.data.error
     );
-  } else if (postEvent.kind === "tool.delta") {
-    return eventSummary(event);
   } else if (postEvent.kind === "tool.post") {
     resultText = summarizeToolResult(
-      toolName,
-      toolInput,
-      postEvent.data.tool_response
-    );
-  } else {
-    return eventSummary(event);
-  }
-  const prefix = primaryInput ? `${name} ${primaryInput}` : name;
-  const prefixText = compactText(prefix, 200);
-  const segments = primaryInput ? [
-    { text: name, role: "verb" },
-    { text: prefixText.slice(name.length), role: "target" }
-  ] : [{ text: prefixText, role: "verb" }];
-  if (!resultText) {
-    return { text: prefixText, segments };
-  }
-  return {
-    text: prefixText,
-    segments,
-    outcome: resultText,
-    outcomeZero: /^0\s/.test(resultText)
-  };
-}
-function harnessSummary(event) {
-  const title = event.display?.title?.trim();
-  if (!title) return void 0;
-  const text = compactText(title, 200);
-  return { text, segments: [{ text, role: "target" }] };
-}
-function postOutcome(postEvent) {
-  if (postEvent.kind === "tool.failure") {
-    return summarizeToolResult(
-      postEvent.data.tool_name,
-      postEvent.data.tool_input,
-      void 0,
-      postEvent.data.error
-    );
-  }
-  if (postEvent.kind === "tool.post") {
-    return summarizeToolResult(
-      postEvent.data.tool_name,
-      postEvent.data.tool_input,
-      postEvent.data.tool_response
-    );
-  }
-  return void 0;
-}
-function toRunStatus(event) {
-  switch (event.data.status) {
-    case "completed":
-      return "SUCCEEDED";
-    case "failed":
-      return "FAILED";
-    case "aborted":
-      return "CANCELLED";
-  }
-}
-
-// src/core/feed/indexedTimeline.ts
-var MAX_SEARCH_CACHE_SIZE = 8;
-var IndexedTimeline = class {
-  // Underlying build cache (reuses existing logic from useTimeline.ts)
-  cache = null;
-  // Secondary indexes (maintained on every update)
-  runIndex = /* @__PURE__ */ new Map();
-  errorPositions = /* @__PURE__ */ new Set();
-  // Run summary tracking (incremental)
-  _runSummaryMap = /* @__PURE__ */ new Map();
-  _runSummariesDirty = true;
-  _runSummariesCache = [];
-  _lastFeedEventsLength = 0;
-  // Search cache
-  searchCache = /* @__PURE__ */ new Map();
-  lastFilteredRef = null;
-  // Instance-level caches (avoid cross-instance leaks in tests)
-  detailCache = /* @__PURE__ */ new WeakMap();
-  searchTextCache = /* @__PURE__ */ new WeakMap();
-  verbose = false;
-  constructor() {
-  }
-  /**
-   * Main update — determines if incremental append is possible,
-   * delegates to existing build/append logic, then updates indexes.
-   */
-  update(feedItems, feedEvents, postByToolUseId, verbose) {
-    this.verbose = verbose;
-    const incremental = canAppendIncrementally(
-      this.cache,
-      feedItems,
-      feedEvents,
-      this.verbose
-    );
-    if (incremental) {
-      this.updateRunSummaries(feedEvents);
-      this.cache = appendTimelineCache(
-        this.cache,
-        feedItems,
-        feedEvents,
-        postByToolUseId
-      );
-    } else {
-      this.rebuildRunSummaries(feedEvents);
-      this.cache = buildTimelineCache(
-        feedItems,
-        feedEvents,
-        postByToolUseId,
-        this.verbose
-      );
-    }
-    this.rebuildIndexes();
-  }
-  getEntries() {
-    return this.cache?.entries ?? [];
-  }
-  /**
-   * Index-based filtering — O(k) where k = matching entries.
-   * Replaces Array.filter() O(n) on every render.
-   */
-  getFilteredView(runFilter, errorsOnly) {
-    const entries = this.getEntries();
-    if ((!runFilter || runFilter === "all") && !errorsOnly) {
-      return entries;
-    }
-    let candidateIndices;
-    if (runFilter && runFilter !== "all") {
-      candidateIndices = this.runIndex.get(runFilter) ?? [];
-    } else {
-      candidateIndices = Array.from({ length: entries.length }, (_, i) => i);
-    }
-    if (errorsOnly) {
-      candidateIndices = candidateIndices.filter(
-        (i) => this.errorPositions.has(i)
-      );
-    }
-    return candidateIndices.map((i) => entries[i]);
-  }
-  /**
-   * Incremental search — only scans new entries since last call with same query.
-   * Returns indices into filteredEntries (not this.entries).
-   */
-  getSearchMatches(filteredEntries, query) {
-    const q = query.trim().toLowerCase();
-    if (!q) return [];
-    if (filteredEntries !== this.lastFilteredRef) {
-      this.searchCache.clear();
-      this.lastFilteredRef = filteredEntries;
-    }
-    const cached = this.searchCache.get(q);
-    if (cached && cached.lastScanned === filteredEntries.length) {
-      return cached.matches;
-    }
-    const startFrom = cached ? cached.lastScanned : 0;
-    const matches = cached ? [...cached.matches] : [];
-    for (let i = startFrom; i < filteredEntries.length; i++) {
-      const searchText = this.getEntrySearchText(filteredEntries[i]);
-      if (searchText.toLowerCase().includes(q)) {
-        matches.push(i);
-      }
-    }
-    this.searchCache.set(q, { matches, lastScanned: filteredEntries.length });
-    if (this.searchCache.size > MAX_SEARCH_CACHE_SIZE) {
-      const oldest = this.searchCache.keys().next().value;
-      if (oldest !== void 0) {
-        this.searchCache.delete(oldest);
-      }
-    }
-    return matches;
-  }
-  // ── Search text helpers ─────────────────────────────────
-  getEntrySearchText(entry) {
-    const cached = this.searchTextCache.get(entry);
-    if (cached !== void 0) return cached;
-    if (!entry.feedEvent) {
-      this.searchTextCache.set(entry, entry.searchText);
-      return entry.searchText;
-    }
-    const details = this.getEntryDetails(entry);
-    const searchText = details ? `${entry.summary}
-${details}` : entry.summary;
-    this.searchTextCache.set(entry, searchText);
-    return searchText;
-  }
-  getEntryDetails(entry) {
-    if (entry.details) return entry.details;
-    if (!entry.feedEvent) return entry.summary;
-    const cached = this.detailCache.get(entry);
-    if (cached !== void 0) return cached;
-    const details = isEventExpandable(entry.feedEvent) ? expansionForEvent(entry.feedEvent) : "";
-    this.detailCache.set(entry, details);
-    return details;
-  }
-  // ── Run summary tracking ─────────────────────────────
-  /**
-   * Returns sorted run summaries. Cached until a run.start/run.end
-   * event invalidates the sorted array.
-   */
-  getRunSummaries() {
-    if (this._runSummariesDirty) {
-      this._runSummariesCache = Array.from(this._runSummaryMap.values()).sort(
-        (a, b) => a.startedAt - b.startedAt
-      );
-      this._runSummariesDirty = false;
-    }
-    return this._runSummariesCache;
-  }
-  processRunEvent(event) {
-    if (event.kind === "run.start") {
-      this._runSummaryMap.set(event.run_id, {
-        runId: event.run_id,
-        title: compactText(
-          event.data.trigger.prompt_preview || "Untitled run",
-          46
-        ),
-        status: "RUNNING",
-        startedAt: event.ts
-      });
-      this._runSummariesDirty = true;
-    } else if (event.kind === "run.end") {
-      const existing = this._runSummaryMap.get(event.run_id);
-      if (existing) {
-        existing.status = toRunStatus(event);
-        existing.endedAt = event.ts;
-      } else {
-        this._runSummaryMap.set(event.run_id, {
-          runId: event.run_id,
-          title: "Untitled run",
-          status: toRunStatus(event),
-          startedAt: event.ts,
-          endedAt: event.ts
-        });
-      }
-      this._runSummariesDirty = true;
-    }
-  }
-  rebuildRunSummaries(feedEvents) {
-    this._runSummaryMap.clear();
-    this._runSummariesDirty = true;
-    this._lastFeedEventsLength = 0;
-    this.updateRunSummaries(feedEvents);
+      toolName,
+      toolInput,
+      postEvent.data.tool_response
+    );
+  } else {
+    return eventSummary(event);
   }
-  updateRunSummaries(feedEvents) {
-    for (let i = this._lastFeedEventsLength; i < feedEvents.length; i++) {
-      this.processRunEvent(feedEvents[i]);
-    }
-    this._lastFeedEventsLength = feedEvents.length;
+  const prefix = primaryInput ? `${name} ${primaryInput}` : name;
+  const prefixText = compactText(prefix, 200);
+  const segments = primaryInput ? [
+    { text: name, role: "verb" },
+    { text: prefixText.slice(name.length), role: "target" }
+  ] : [{ text: prefixText, role: "verb" }];
+  if (!resultText) {
+    return { text: prefixText, segments };
   }
-  // ── Index maintenance ─────────────────────────────────
-  addToIndex(entry, index) {
-    const runId = entry.runId ?? "__none__";
-    let indices = this.runIndex.get(runId);
-    if (!indices) {
-      indices = [];
-      this.runIndex.set(runId, indices);
-    }
-    indices.push(index);
-    if (entry.error) {
-      this.errorPositions.add(index);
-    }
+  return {
+    text: prefixText,
+    segments,
+    outcome: resultText,
+    outcomeZero: /^0\s/.test(resultText)
+  };
+}
+function mergedEventOperation(event, postEvent) {
+  if (!postEvent) return eventOperation(event);
+  const pair = TOOL_PAIRS[postEvent.kind];
+  if (!pair) return eventOperation(event);
+  return pair.operation(event, postEvent);
+}
+function mergedEventLabel(event, postEvent) {
+  if (!postEvent) return eventLabel(event);
+  const pair = TOOL_PAIRS[postEvent.kind];
+  if (!pair) return eventLabel(event);
+  return pair.label(event, postEvent);
+}
+function mergedEventSummary(event, postEvent) {
+  if (!postEvent) return eventSummary(event);
+  if (event.kind !== "tool.pre" && event.kind !== "permission.request") {
+    return eventSummary(event);
   }
-  rebuildIndexes() {
-    this.runIndex.clear();
-    this.errorPositions.clear();
-    this.searchCache.clear();
-    const entries = this.getEntries();
-    for (let i = 0; i < entries.length; i++) {
-      this.addToIndex(entries[i], i);
-    }
+  const pair = TOOL_PAIRS[postEvent.kind];
+  if (!pair) return eventSummary(event);
+  return pair.summary(event, postEvent);
+}
+var VERBOSE_ONLY_KINDS = /* @__PURE__ */ new Set([
+  "session.start",
+  "session.end",
+  "run.start",
+  "run.end",
+  "unknown.hook",
+  "compact.pre",
+  "config.change",
+  "turn.diff",
+  "usage.update",
+  "reasoning.summary"
+]);
+function toRunStatus(event) {
+  switch (event.data.status) {
+    case "completed":
+      return "SUCCEEDED";
+    case "failed":
+      return "FAILED";
+    case "aborted":
+      return "CANCELLED";
   }
-};
+}
 
 // src/core/feed/toolDisplay.ts
 function prop2(obj, key) {
@@ -6992,14 +6742,9 @@ function resolveEventToolColumn(event) {
   }
 }
 
-// src/ui/hooks/useTimeline.ts
-var detailCache = /* @__PURE__ */ new WeakMap();
-var searchTextCache = /* @__PURE__ */ new WeakMap();
-var EMPTY_MATCHES = Object.freeze([]);
-var EMPTY_MATCH_SET = Object.freeze(/* @__PURE__ */ new Set());
-function subagentActorLabel(agentType, agentId) {
-  void agentType;
-  void agentId;
+// src/core/feed/indexedTimeline.ts
+var MAX_SEARCH_CACHE_SIZE = 8;
+function subagentActorLabel(_agentType, _agentId) {
   return "SUB AGENT";
 }
 function buildSubagentTypeMap(feedEvents) {
@@ -7170,7 +6915,7 @@ function sameFeedEventPrefix(previous, next) {
 }
 function canAppendIncrementally(previous, feedItems, feedEvents, verbose) {
   if (!previous) return false;
-  if (previous.verbose !== !!verbose) return false;
+  if (previous.verbose !== verbose) return false;
   return sameFeedItemPrefix(previous.feedItems, feedItems) && sameFeedEventPrefix(previous.feedEvents, feedEvents);
 }
 function buildTimelineCache(feedItems, feedEvents, postByToolUseId, verbose) {
@@ -7202,109 +6947,274 @@ function buildTimelineCache(feedItems, feedEvents, postByToolUseId, verbose) {
       activeRunId = void 0;
     }
   }
-  computeDuplicateActors(entries);
-  return {
-    feedItems,
-    feedEvents,
-    entries,
-    activeRunId,
-    messageCounter,
-    subagentTypes,
-    pendingEntryIndexByToolUseId,
-    verbose: !!verbose
-  };
-}
-function appendTimelineCache(previous, feedItems, feedEvents, postByToolUseId) {
-  const entries = previous.entries.slice();
-  const subagentTypes = new Map(previous.subagentTypes);
-  updateSubagentTypeMap(
-    subagentTypes,
-    feedEvents.slice(previous.feedEvents.length)
-  );
-  const pendingEntryIndexByToolUseId = new Map(
-    previous.pendingEntryIndexByToolUseId
-  );
-  let activeRunId = previous.activeRunId;
-  let messageCounter = previous.messageCounter;
-  for (const item of feedItems.slice(previous.feedItems.length)) {
-    if (item.type === "message") {
-      const index = entries.push(
-        buildMessageEntry(item.data, activeRunId, messageCounter++)
-      ) - 1;
-      recomputeDuplicateActorsAround(entries, index);
-      continue;
+  computeDuplicateActors(entries);
+  return {
+    feedItems,
+    feedEvents,
+    entries,
+    activeRunId,
+    messageCounter,
+    subagentTypes,
+    pendingEntryIndexByToolUseId,
+    verbose
+  };
+}
+function appendTimelineCache(previous, feedItems, feedEvents, postByToolUseId) {
+  const entries = previous.entries.slice();
+  const subagentTypes = new Map(previous.subagentTypes);
+  updateSubagentTypeMap(
+    subagentTypes,
+    feedEvents.slice(previous.feedEvents.length)
+  );
+  const pendingEntryIndexByToolUseId = new Map(
+    previous.pendingEntryIndexByToolUseId
+  );
+  let activeRunId = previous.activeRunId;
+  let messageCounter = previous.messageCounter;
+  for (const item of feedItems.slice(previous.feedItems.length)) {
+    if (item.type === "message") {
+      const index = entries.push(
+        buildMessageEntry(item.data, activeRunId, messageCounter++)
+      ) - 1;
+      recomputeDuplicateActorsAround(entries, index);
+      continue;
+    }
+    const event = item.data;
+    if (event.kind === "run.start") {
+      activeRunId = event.run_id;
+    }
+    const resolvedToolUseId = pendingToolUpdateUseId(event);
+    if (resolvedToolUseId) {
+      const pendingIndex = pendingEntryIndexByToolUseId.get(resolvedToolUseId);
+      if (pendingIndex !== void 0) {
+        const pendingEntry = entries[pendingIndex];
+        if (pendingEntry.feedEvent) {
+          entries[pendingIndex] = buildEventEntry(
+            pendingEntry.feedEvent,
+            subagentTypes,
+            event
+          );
+          if (event.kind === "tool.post" || event.kind === "tool.failure") {
+            pendingEntryIndexByToolUseId.delete(resolvedToolUseId);
+          }
+          recomputeDuplicateActorsAround(entries, pendingIndex);
+        }
+      }
+      continue;
+    }
+    const entry = maybeBuildEventEntry(
+      event,
+      subagentTypes,
+      postByToolUseId,
+      previous.verbose
+    );
+    if (entry) {
+      const index = entries.push(entry) - 1;
+      recomputeDuplicateActorsAround(entries, index);
+      rememberPendingEntry(pendingEntryIndexByToolUseId, entry, index);
+    }
+    if (event.kind === "run.end") {
+      activeRunId = void 0;
+    }
+  }
+  return {
+    feedItems,
+    feedEvents,
+    entries,
+    activeRunId,
+    messageCounter,
+    subagentTypes,
+    pendingEntryIndexByToolUseId,
+    verbose: previous.verbose
+  };
+}
+var IndexedTimeline = class {
+  cache = null;
+  runIndex = /* @__PURE__ */ new Map();
+  errorPositions = /* @__PURE__ */ new Set();
+  _runSummaryMap = /* @__PURE__ */ new Map();
+  _runSummariesDirty = true;
+  _runSummariesCache = [];
+  _lastFeedEventsLength = 0;
+  searchCache = /* @__PURE__ */ new Map();
+  lastFilteredRef = null;
+  detailCache = /* @__PURE__ */ new WeakMap();
+  searchTextCache = /* @__PURE__ */ new WeakMap();
+  verbose = false;
+  update(feedItems, feedEvents, postByToolUseId, verbose) {
+    this.verbose = verbose;
+    const incremental = canAppendIncrementally(
+      this.cache,
+      feedItems,
+      feedEvents,
+      this.verbose
+    );
+    if (incremental) {
+      this.updateRunSummaries(feedEvents);
+      this.cache = appendTimelineCache(
+        this.cache,
+        feedItems,
+        feedEvents,
+        postByToolUseId
+      );
+    } else {
+      this.rebuildRunSummaries(feedEvents);
+      this.cache = buildTimelineCache(
+        feedItems,
+        feedEvents,
+        postByToolUseId,
+        this.verbose
+      );
+    }
+    this.rebuildIndexes();
+  }
+  getEntries() {
+    return this.cache?.entries ?? [];
+  }
+  getFilteredView(runFilter, errorsOnly) {
+    const entries = this.getEntries();
+    if ((!runFilter || runFilter === "all") && !errorsOnly) {
+      return entries;
+    }
+    let candidateIndices;
+    if (runFilter && runFilter !== "all") {
+      candidateIndices = this.runIndex.get(runFilter) ?? [];
+    } else {
+      candidateIndices = Array.from({ length: entries.length }, (_, i) => i);
+    }
+    if (errorsOnly) {
+      candidateIndices = candidateIndices.filter(
+        (i) => this.errorPositions.has(i)
+      );
+    }
+    return candidateIndices.map((i) => entries[i]);
+  }
+  getSearchMatches(filteredEntries, query) {
+    const q = query.trim().toLowerCase();
+    if (!q) return [];
+    if (filteredEntries !== this.lastFilteredRef) {
+      this.searchCache.clear();
+      this.lastFilteredRef = filteredEntries;
+    }
+    const cached = this.searchCache.get(q);
+    if (cached && cached.lastScanned === filteredEntries.length) {
+      return cached.matches;
+    }
+    const startFrom = cached ? cached.lastScanned : 0;
+    const matches = cached ? [...cached.matches] : [];
+    for (let i = startFrom; i < filteredEntries.length; i++) {
+      const searchText = this.getEntrySearchText(filteredEntries[i]);
+      if (searchText.toLowerCase().includes(q)) {
+        matches.push(i);
+      }
+    }
+    this.searchCache.set(q, { matches, lastScanned: filteredEntries.length });
+    if (this.searchCache.size > MAX_SEARCH_CACHE_SIZE) {
+      const oldest = this.searchCache.keys().next().value;
+      if (oldest !== void 0) {
+        this.searchCache.delete(oldest);
+      }
+    }
+    return matches;
+  }
+  getEntrySearchText(entry) {
+    const cached = this.searchTextCache.get(entry);
+    if (cached !== void 0) return cached;
+    if (!entry.feedEvent) {
+      this.searchTextCache.set(entry, entry.searchText);
+      return entry.searchText;
+    }
+    const details = this.getEntryDetails(entry);
+    const searchText = details ? `${entry.summary}
+${details}` : entry.summary;
+    this.searchTextCache.set(entry, searchText);
+    return searchText;
+  }
+  getEntryDetails(entry) {
+    if (entry.details) return entry.details;
+    if (!entry.feedEvent) return entry.summary;
+    const cached = this.detailCache.get(entry);
+    if (cached !== void 0) return cached;
+    const details = isEventExpandable(entry.feedEvent) ? expansionForEvent(entry.feedEvent) : "";
+    this.detailCache.set(entry, details);
+    return details;
+  }
+  getRunSummaries() {
+    if (this._runSummariesDirty) {
+      this._runSummariesCache = Array.from(this._runSummaryMap.values()).sort(
+        (a, b) => a.startedAt - b.startedAt
+      );
+      this._runSummariesDirty = false;
     }
-    const event = item.data;
+    return this._runSummariesCache;
+  }
+  processRunEvent(event) {
     if (event.kind === "run.start") {
-      activeRunId = event.run_id;
-    }
-    const resolvedToolUseId = pendingToolUpdateUseId(event);
-    if (resolvedToolUseId) {
-      const pendingIndex = pendingEntryIndexByToolUseId.get(resolvedToolUseId);
-      if (pendingIndex !== void 0) {
-        const pendingEntry = entries[pendingIndex];
-        if (pendingEntry.feedEvent) {
-          entries[pendingIndex] = buildEventEntry(
-            pendingEntry.feedEvent,
-            subagentTypes,
-            event
-          );
-          if (event.kind === "tool.post" || event.kind === "tool.failure") {
-            pendingEntryIndexByToolUseId.delete(resolvedToolUseId);
-          }
-          recomputeDuplicateActorsAround(entries, pendingIndex);
-        }
+      this._runSummaryMap.set(event.run_id, {
+        runId: event.run_id,
+        title: compactText(
+          event.data.trigger.prompt_preview || "Untitled run",
+          46
+        ),
+        status: "RUNNING",
+        startedAt: event.ts
+      });
+      this._runSummariesDirty = true;
+    } else if (event.kind === "run.end") {
+      const existing = this._runSummaryMap.get(event.run_id);
+      if (existing) {
+        existing.status = toRunStatus(event);
+        existing.endedAt = event.ts;
+      } else {
+        this._runSummaryMap.set(event.run_id, {
+          runId: event.run_id,
+          title: "Untitled run",
+          status: toRunStatus(event),
+          startedAt: event.ts,
+          endedAt: event.ts
+        });
       }
-      continue;
+      this._runSummariesDirty = true;
     }
-    const entry = maybeBuildEventEntry(
-      event,
-      subagentTypes,
-      postByToolUseId,
-      previous.verbose
-    );
-    if (entry) {
-      const index = entries.push(entry) - 1;
-      recomputeDuplicateActorsAround(entries, index);
-      rememberPendingEntry(pendingEntryIndexByToolUseId, entry, index);
+  }
+  rebuildRunSummaries(feedEvents) {
+    this._runSummaryMap.clear();
+    this._runSummariesDirty = true;
+    this._lastFeedEventsLength = 0;
+    this.updateRunSummaries(feedEvents);
+  }
+  updateRunSummaries(feedEvents) {
+    for (let i = this._lastFeedEventsLength; i < feedEvents.length; i++) {
+      this.processRunEvent(feedEvents[i]);
     }
-    if (event.kind === "run.end") {
-      activeRunId = void 0;
+    this._lastFeedEventsLength = feedEvents.length;
+  }
+  addToIndex(entry, index) {
+    const runId = entry.runId ?? "__none__";
+    let indices = this.runIndex.get(runId);
+    if (!indices) {
+      indices = [];
+      this.runIndex.set(runId, indices);
+    }
+    indices.push(index);
+    if (entry.error) {
+      this.errorPositions.add(index);
     }
   }
-  return {
-    feedItems,
-    feedEvents,
-    entries,
-    activeRunId,
-    messageCounter,
-    subagentTypes,
-    pendingEntryIndexByToolUseId,
-    verbose: previous.verbose
-  };
-}
-function getTimelineEntryDetails(entry) {
-  if (entry.details) return entry.details;
-  if (!entry.feedEvent) return entry.summary;
-  const cached = detailCache.get(entry);
-  if (cached !== void 0) return cached;
-  const details = isEventExpandable(entry.feedEvent) ? expansionForEvent(entry.feedEvent) : "";
-  detailCache.set(entry, details);
-  return details;
-}
-function getTimelineEntrySearchText(entry) {
-  const cached = searchTextCache.get(entry);
-  if (cached !== void 0) return cached;
-  if (!entry.feedEvent) {
-    searchTextCache.set(entry, entry.searchText);
-    return entry.searchText;
+  rebuildIndexes() {
+    this.runIndex.clear();
+    this.errorPositions.clear();
+    this.searchCache.clear();
+    const entries = this.getEntries();
+    for (let i = 0; i < entries.length; i++) {
+      this.addToIndex(entries[i], i);
+    }
   }
-  const details = getTimelineEntryDetails(entry);
-  const searchText = details ? `${entry.summary}
-${details}` : entry.summary;
-  searchTextCache.set(entry, searchText);
-  return searchText;
-}
+};
+
+// src/ui/hooks/useTimeline.ts
+var EMPTY_MATCHES = Object.freeze([]);
+var EMPTY_MATCH_SET = Object.freeze(/* @__PURE__ */ new Set());
 function useTimeline({
   feedItems,
   feedEvents,
@@ -7362,12 +7272,17 @@ function useTimeline({
     () => searchMatches === EMPTY_MATCHES ? EMPTY_MATCH_SET : new Set(searchMatches),
     [searchMatches]
   );
+  const getEntrySearchText = useCallback10(
+    (entry) => indexedRef.current.getEntrySearchText(entry),
+    []
+  );
   return {
     timelineEntries,
     runSummaries,
     filteredEntries,
     searchMatches,
-    searchMatchSet
+    searchMatchSet,
+    getEntrySearchText
   };
 }
 
@@ -7448,7 +7363,7 @@ function useLayout({
 
 // src/ui/hooks/usePager.ts
 import process5 from "process";
-import { useState as useState10, useCallback as useCallback10, useRef as useRef11, useEffect as useEffect9 } from "react";
+import { useState as useState10, useCallback as useCallback11, useRef as useRef11, useEffect as useEffect9 } from "react";
 import { useInput as useInput11 } from "ink";
 
 // src/shared/utils/clipboard.ts
@@ -7477,6 +7392,30 @@ function getClipboardCommand() {
   return null;
 }
 
+// src/core/feed/defaultRender.ts
+var DEFAULT_RENDER = /* @__PURE__ */ new Set([
+  "compact.post",
+  "task.created",
+  "cwd.changed",
+  "file.changed",
+  "stop.failure",
+  "permission.denied",
+  "elicitation.request",
+  "elicitation.result",
+  "channel.permission.relayed",
+  "channel.permission.resolved",
+  "channel.question.relayed",
+  "channel.question.resolved",
+  "channel.chat.inbound",
+  "channel.chat.outbound",
+  "gateway.function.invoked",
+  "gateway.function.completed",
+  "gateway.function.failed"
+]);
+function isDefaultRenderKind(k) {
+  return DEFAULT_RENDER.has(k);
+}
+
 // src/ui/tooling/toolExtractors.ts
 var EXT_TO_LANGUAGE = {
   ".ts": "typescript",
@@ -8571,13 +8510,13 @@ function usePager({
   const pagerActiveRef = useRef11(false);
   const pagerEntryIdRef = useRef11(null);
   const lastPairedPostRef = useRef11(void 0);
-  const clearCopyToastTimer = useCallback10(() => {
+  const clearCopyToastTimer = useCallback11(() => {
     if (copyToastTimerRef.current) {
       clearTimeout(copyToastTimerRef.current);
       copyToastTimerRef.current = null;
     }
   }, []);
-  const paintPager = useCallback10(() => {
+  const paintPager = useCallback11(() => {
     const lines = pagerLinesRef.current;
     const scroll = pagerScrollRef.current;
     const contentRows = pagerContentRows();
@@ -8600,7 +8539,7 @@ function usePager({
       margin + source_default.dim(`${pos}  \u2191/\u2193 j/k scroll  PgUp/PgDn page  y copy  q exit`)
     );
   }, []);
-  const scrollPager = useCallback10(
+  const scrollPager = useCallback11(
     (delta) => {
       const contentRows = pagerContentRows();
       const maxScroll = Math.max(0, pagerLinesRef.current.length - contentRows);
@@ -8612,7 +8551,7 @@ function usePager({
     },
     [paintPager]
   );
-  const handleExpandForPager = useCallback10(() => {
+  const handleExpandForPager = useCallback11(() => {
     const entry = displayedEntriesRef.current.find((e) => e.id === feedCursorId);
     if (!entry?.expandable) return;
     pendingPagerEntryRef.current = entry;
@@ -8755,7 +8694,7 @@ function usePager({
 }
 
 // src/ui/hooks/useFrameChrome.ts
-import { useMemo as useMemo10, useCallback as useCallback11 } from "react";
+import { useMemo as useMemo10, useCallback as useCallback12 } from "react";
 
 // src/ui/layout/buildFrameLines.ts
 function buildHintPairs(pairs) {
@@ -8945,7 +8884,7 @@ function useFrameChrome({
       sectionBorder: `${glyphs.teeLeft}${spliceJunction(hFill, glyphs.cross)}${glyphs.teeRight}`
     };
   }, [glyphs, innerWidth, dividerColumn]);
-  const frameLine = useCallback11(
+  const frameLine = useCallback12(
     (content) => `${glyphs.vertical}${fitAnsi(content, innerWidth)}${glyphs.vertical}`,
     [glyphs.vertical, innerWidth]
   );
@@ -11122,24 +11061,24 @@ function renderYankLines(entry, width, theme) {
 }
 
 // src/setup/SetupWizard.tsx
-import { useState as useState14, useCallback as useCallback14, useEffect as useEffect10, useRef as useRef13 } from "react";
+import { useState as useState14, useCallback as useCallback15, useEffect as useEffect10, useRef as useRef13 } from "react";
 import { Box as Box16, Text as Text22, useInput as useInput13 } from "ink";
 
 // src/setup/useSetupState.ts
-import { useState as useState12, useCallback as useCallback12 } from "react";
+import { useState as useState12, useCallback as useCallback13 } from "react";
 var TOTAL_STEPS = 2;
 function useSetupState() {
   const [stepIndex, setStepIndex] = useState12(0);
   const [stepState, setStepState] = useState12("selecting");
-  const startVerifying = useCallback12(() => setStepState("verifying"), []);
-  const markSuccess = useCallback12(() => setStepState("success"), []);
-  const markError = useCallback12(() => setStepState("error"), []);
-  const retry = useCallback12(() => setStepState("selecting"), []);
-  const advance = useCallback12(() => {
+  const startVerifying = useCallback13(() => setStepState("verifying"), []);
+  const markSuccess = useCallback13(() => setStepState("success"), []);
+  const markError = useCallback13(() => setStepState("error"), []);
+  const retry = useCallback13(() => setStepState("selecting"), []);
+  const advance = useCallback13(() => {
     setStepIndex((prev) => prev + 1);
     setStepState("selecting");
   }, []);
-  const retreat = useCallback12(() => {
+  const retreat = useCallback13(() => {
     setStepIndex((prev) => Math.max(0, prev - 1));
     setStepState("selecting");
   }, []);
@@ -11193,7 +11132,7 @@ function ThemeStep({ onComplete, onPreview }) {
 }
 
 // src/setup/steps/HarnessStep.tsx
-import { useState as useState13, useCallback as useCallback13 } from "react";
+import { useState as useState13, useCallback as useCallback14 } from "react";
 import { Box as Box13, Text as Text19 } from "ink";
 import { jsx as jsx18, jsxs as jsxs15 } from "react/jsx-runtime";
 function HarnessStep({ onComplete, onError }) {
@@ -11202,7 +11141,7 @@ function HarnessStep({ onComplete, onError }) {
   const [status, setStatus] = useState13("selecting");
   const [message, setMessage] = useState13("");
   const [checks, setChecks] = useState13([]);
-  const renderCheckLine = useCallback13(
+  const renderCheckLine = useCallback14(
     (check) => {
       const glyph = check.status === "pass" ? "\u2713" : check.status === "fail" ? "\u2717" : "!";
       const color = check.status === "pass" ? theme.status.success : check.status === "fail" ? theme.status.error : theme.status.warning;
@@ -11210,7 +11149,7 @@ function HarnessStep({ onComplete, onError }) {
     },
     [theme.status.error, theme.status.success, theme.status.warning]
   );
-  const handleSelect = useCallback13(
+  const handleSelect = useCallback14(
     (value) => {
       const capability = capabilities.find(
         (c2) => c2.id === value
@@ -11345,7 +11284,7 @@ function SetupWizard({ onComplete, onThemePreview }) {
   const [writeRetryCount, setWriteRetryCount] = useState14(0);
   const themePreviewRef = useRef13(result.theme);
   const completedRef = useRef13(false);
-  const handleThemeComplete = useCallback14(
+  const handleThemeComplete = useCallback15(
     (theme2) => {
       themePreviewRef.current = theme2;
       setResult((prev) => ({ ...prev, theme: theme2 }));
@@ -11354,25 +11293,25 @@ function SetupWizard({ onComplete, onThemePreview }) {
     },
     [markSuccess, onThemePreview]
   );
-  const handleThemePreview = useCallback14(
+  const handleThemePreview = useCallback15(
     (nextTheme) => {
       themePreviewRef.current = nextTheme;
       onThemePreview?.(nextTheme);
     },
     [onThemePreview]
   );
-  const handleHarnessComplete = useCallback14(
+  const handleHarnessComplete = useCallback15(
     (harness) => {
       setResult((prev) => ({ ...prev, harness }));
       markSuccess();
     },
     [markSuccess]
   );
-  const handleHarnessSkip = useCallback14(() => {
+  const handleHarnessSkip = useCallback15(() => {
     setResult((prev) => ({ ...prev, harness: void 0 }));
     markSuccess();
   }, [markSuccess]);
-  const handleSkipShortcut = useCallback14(() => {
+  const handleSkipShortcut = useCallback15(() => {
     if (stepState !== "selecting" || isComplete) {
       return;
     }
@@ -11493,7 +11432,7 @@ function SetupWizard({ onComplete, onThemePreview }) {
 }
 
 // src/app/workflow/WorkflowPicker.tsx
-import { useState as useState15, useCallback as useCallback15, useEffect as useEffect11 } from "react";
+import { useState as useState15, useCallback as useCallback16, useEffect as useEffect11 } from "react";
 import { Box as Box17, Text as Text23, useInput as useInput14, useStdout as useStdout7 } from "ink";
 
 // src/core/workflows/workflowOptions.ts
@@ -11593,7 +11532,7 @@ function WorkflowPicker({
       }
     }
   });
-  const handleSelect = useCallback15(
+  const handleSelect = useCallback16(
     (value) => {
       if (value === "default") {
         writeProjectConfig(projectDir, { activeWorkflow: "default" });
@@ -11631,7 +11570,7 @@ function WorkflowPicker({
     },
     [onComplete, projectDir]
   );
-  const handleMcpComplete = useCallback15(
+  const handleMcpComplete = useCallback16(
     (choices) => {
       if (phase.type !== "mcp-options") return;
       const { workflowName } = phase;
@@ -11694,7 +11633,7 @@ function WorkflowPicker({
 }
 
 // src/app/modelPreferences/ModelPicker.tsx
-import { useState as useState16, useEffect as useEffect12, useCallback as useCallback16 } from "react";
+import { useState as useState16, useEffect as useEffect12, useCallback as useCallback17 } from "react";
 import { Box as Box18, Text as Text24, useInput as useInput15, useStdout as useStdout8 } from "ink";
 
 // src/app/modelPreferences/listAvailableModels.ts
@@ -11761,7 +11700,7 @@ function ModelPicker({
   const { stdout } = useStdout8();
   const frameWidth = Math.min(stdout.columns - 4, 72);
   const [phase, setPhase] = useState16({ type: "loading" });
-  const loadModels = useCallback16(() => {
+  const loadModels = useCallback17(() => {
     setPhase({ type: "loading" });
     setTimeout(() => {
       void listAvailableModels({ harness, runtime }).then((options) => {
@@ -11793,7 +11732,7 @@ function ModelPicker({
       loadModels();
     }
   });
-  const handleSelect = useCallback16(
+  const handleSelect = useCallback17(
     (value) => {
       setPhase({ type: "saving", model: value });
       setTimeout(() => {
@@ -11882,7 +11821,7 @@ function useRuntimeSelectors() {
   const questionQueueCount = useHookContextSelector((v) => v.questionQueueCount);
   const resolveQuestion = useHookContextSelector((v) => v.resolveQuestion);
   const isServerRunning = useHookContextSelector((v) => v.isServerRunning);
-  const runtimeError = useHookContextSelector((v) => v.runtimeError);
+  const runtimeError2 = useHookContextSelector((v) => v.runtimeError);
   const postByToolUseId = useHookContextSelector((v) => v.postByToolUseId);
   const allocateSeq = useHookContextSelector((v) => v.allocateSeq);
   const clearEvents = useHookContextSelector((v) => v.clearEvents);
@@ -11907,7 +11846,7 @@ function useRuntimeSelectors() {
     questionQueueCount,
     resolveQuestion,
     isServerRunning,
-    runtimeError,
+    runtimeError: runtimeError2,
     postByToolUseId,
     allocateSeq,
     clearEvents,
@@ -11958,16 +11897,16 @@ function useTimelineCurrentRun(currentRun) {
 }
 
 // src/app/shell/useShellInput.ts
-import { useState as useState17, useCallback as useCallback17, useRef as useRef14 } from "react";
+import { useState as useState17, useCallback as useCallback18, useRef as useRef14 } from "react";
 function deriveInputMode(value) {
   if (value.startsWith("/")) return "command";
   if (value.startsWith(":")) return "search";
   return "normal";
 }
-function findFirstSearchMatch(entries, query, startIndex) {
+function findFirstSearchMatch(entries, query, startIndex, getEntrySearchText) {
   const q = query.toLowerCase();
   for (let i = startIndex; i < entries.length; i++) {
-    if (getTimelineEntrySearchText(entries[i]).toLowerCase().includes(q)) {
+    if (getEntrySearchText(entries[i]).toLowerCase().includes(q)) {
       return i;
     }
   }
@@ -11981,13 +11920,14 @@ function useShellInput({
   submitSearchQuery,
   submitPromptOrSlashCommand,
   displayedEntriesRef,
+  getEntrySearchText,
   getSelectedCommand
 }) {
   const setInputValueRef = useRef14(() => {
   });
   const inputValueRef = useRef14("");
   const [inputRows, setInputRows] = useState17(1);
-  const syncInputModeFromValue = useCallback17(
+  const syncInputModeFromValue = useCallback18(
     (value) => {
       const nextMode = deriveInputMode(value);
       setInputMode(nextMode);
@@ -11998,7 +11938,7 @@ function useShellInput({
     [setInputMode, setSearchQuery]
   );
   const inputContentWidthRef = useRef14(1);
-  const handleSetValueRef = useCallback17(
+  const handleSetValueRef = useCallback18(
     (setValue) => {
       setInputValueRef.current = (value) => {
         inputValueRef.current = value;
@@ -12009,7 +11949,7 @@ function useShellInput({
     },
     [syncInputModeFromValue]
   );
-  const handleInputSubmit = useCallback17(
+  const handleInputSubmit = useCallback18(
     (rawValue) => {
       const trimmed = rawValue.trim();
       if (trimmed) {
@@ -12023,7 +11963,12 @@ function useShellInput({
           }
         } else if (inputMode === "search") {
           const query = trimmed.replace(/^:/, "").trim();
-          const firstIdx = query.length > 0 ? findFirstSearchMatch(displayedEntriesRef.current, query, 0) : -1;
+          const firstIdx = query.length > 0 ? findFirstSearchMatch(
+            displayedEntriesRef.current,
+            query,
+            0,
+            getEntrySearchText
+          ) : -1;
           submitSearchQuery(query, firstIdx >= 0 ? firstIdx : null);
         } else {
           submitPromptOrSlashCommand(trimmed);
@@ -12041,10 +11986,11 @@ function useShellInput({
       getSelectedCommand,
       closeInput,
       submitSearchQuery,
-      displayedEntriesRef
+      displayedEntriesRef,
+      getEntrySearchText
     ]
   );
-  const handleMainInputChange = useCallback17(
+  const handleMainInputChange = useCallback18(
     (value) => {
       inputValueRef.current = value;
       syncInputModeFromValue(value);
@@ -12850,7 +12796,7 @@ function AppContent({
   const searchQuery = uiState.searchQuery;
   const perfEnabled = isPerfEnabled();
   usePerfRenderLog(perfEnabled, "app.main.content.render");
-  const handleSectionProfilerRender = useCallback18(
+  const handleSectionProfilerRender = useCallback19(
     (id, phaseName, actualDuration, baseDuration, startTime, commitTime) => {
       logReactCommit(
         id,
@@ -12884,7 +12830,7 @@ function AppContent({
     isServerRunning,
     recordTokens,
     restoredTokens,
-    runtimeError,
+    runtimeError: runtimeError2,
     hookCommandFeed
   } = useRuntimeSelectors();
   const currentSessionId = session?.session_id ?? null;
@@ -12892,7 +12838,7 @@ function AppContent({
   const timelineCurrentRun = useTimelineCurrentRun(currentRun);
   const harnessLabel = detectHarness(harness);
   const shouldTrackClaudeStartup = shouldTrackStartupDiagnostics(harness);
-  const onExitTokens = useCallback18(
+  const onExitTokens = useCallback19(
     (tokens) => {
       if (session?.session_id) {
         recordTokens(session.session_id, tokens);
@@ -12900,7 +12846,7 @@ function AppContent({
     },
     [session?.session_id, recordTokens]
   );
-  const emitClaudeStartupDiagnostics = useCallback18(
+  const emitClaudeStartupDiagnostics = useCallback19(
     (event) => {
       trackClaudeStartupFailed({
         harness,
@@ -12911,7 +12857,7 @@ function AppContent({
     },
     [harness]
   );
-  const onProcessLifecycleEvent = useCallback18(
+  const onProcessLifecycleEvent = useCallback19(
     (event) => {
       const startupAttempt = startupAttemptRef.current;
       const isStartupFailure = shouldTrackClaudeStartup && startupAttempt !== null;
@@ -13029,7 +12975,7 @@ function AppContent({
       if (!current) {
         return current;
       }
-      const isActiveHookServerStartupFailure = current.failureStage === "startup_timeout" && !!runtimeError && !isServerRunning && current.message === runtimeError.message;
+      const isActiveHookServerStartupFailure = current.failureStage === "startup_timeout" && !!runtimeError2 && !isServerRunning && current.message === runtimeError2.message;
       if (isActiveHookServerStartupFailure) {
         return current;
       }
@@ -13038,21 +12984,21 @@ function AppContent({
       }
       return null;
     });
-  }, [feedEvents.length, isServerRunning, runtimeError]);
+  }, [feedEvents.length, isServerRunning, runtimeError2]);
   useEffect14(() => {
     if (!shouldTrackClaudeStartup || !isTelemetryEnabled()) return;
-    if (!runtimeError || isServerRunning) {
+    if (!runtimeError2 || isServerRunning) {
       runtimeStartupDiagnosticsSignatureRef.current = null;
       return;
     }
-    const signature = `${runtimeError.code}:${runtimeError.message}`;
+    const signature = `${runtimeError2.code}:${runtimeError2.message}`;
     if (signature === runtimeStartupDiagnosticsSignatureRef.current) {
       return;
     }
     runtimeStartupDiagnosticsSignatureRef.current = signature;
     const diagnosticsEvent = createPendingStartupDiagnosticsEvent({
       failureStage: "startup_timeout",
-      message: runtimeError.message,
+      message: runtimeError2.message,
       feedEventCount: feedEvents.length
     });
     if (diagnosticsConsent === true) {
@@ -13065,7 +13011,7 @@ function AppContent({
     emitClaudeStartupDiagnostics,
     feedEvents.length,
     isServerRunning,
-    runtimeError,
+    runtimeError2,
     shouldTrackClaudeStartup
   ]);
   useEffect14(() => {
@@ -13080,7 +13026,7 @@ function AppContent({
         return;
       }
       const derivedFailure = deriveStartupTimeoutFailure({
-        runtimeError,
+        runtimeError: runtimeError2,
         isServerRunning,
         isHarnessRunning,
         harnessLabel
@@ -13117,10 +13063,10 @@ function AppContent({
     harnessLabel,
     isHarnessRunning,
     isServerRunning,
-    runtimeError,
+    runtimeError2,
     shouldTrackClaudeStartup
   ]);
-  const addMessage = useCallback18(
+  const addMessage = useCallback19(
     (role, content) => {
       const newMessage = {
         id: generateId(),
@@ -13134,7 +13080,7 @@ function AppContent({
     },
     [allocateSeq]
   );
-  const clearScreen = useCallback18(() => {
+  const clearScreen = useCallback19(() => {
     onSessionTelemetrySnapshot(metrics);
     clearEvents();
     process6.stdout.write("\x1B[2J\x1B[3J\x1B[H");
@@ -13148,7 +13094,7 @@ function AppContent({
     postByToolUseId,
     verbose
   });
-  const { runSummaries, filteredEntries, searchMatches } = timeline;
+  const { runSummaries, filteredEntries, searchMatches, getEntrySearchText } = timeline;
   const todoPanel = useTodoPanel({
     tasks,
     isWorking: appMode.type === "working",
@@ -13209,7 +13155,7 @@ function AppContent({
     messageEntryLineOffsets: [],
     messageContentRows: 0
   });
-  const dispatchUi = useCallback18((action) => {
+  const dispatchUi = useCallback19((action) => {
     setUiState(
       (prev) => reduceSessionUiState(prev, action, uiContextRef.current)
     );
@@ -13221,7 +13167,7 @@ function AppContent({
     previousWorkflowPickerVisibleRef.current = workflowPickerVisible;
     previousModelPickerVisibleRef.current = modelPickerVisible;
   }, [dispatchUi, workflowPickerVisible, modelPickerVisible]);
-  const submitPromptOrSlashCommand = useCallback18(
+  const submitPromptOrSlashCommand = useCallback19(
     (value) => {
       if (!value.trim()) return;
       inputHistory.push(value);
@@ -13230,13 +13176,13 @@ function AppContent({
         setPendingStartupDiagnostics(null);
         setStartupFailure(null);
         addMessage("user", result.text);
-        if (!isServerRunning && runtimeError) {
+        if (!isServerRunning && runtimeError2) {
           setStartupFailure({
-            message: runtimeError.message,
-            failureCode: runtimeError.code === "socket_path_too_long" ? "socket_path_too_long" : "hook_server_unavailable"
+            message: runtimeError2.message,
+            failureCode: runtimeError2.code === "socket_path_too_long" ? "socket_path_too_long" : "hook_server_unavailable"
           });
           emitNotification(
-            `Athena failed to start ${harnessLabel}: ${runtimeError.message}`,
+            `Athena failed to start ${harnessLabel}: ${runtimeError2.message}`,
             `${harnessLabel} Startup Error`
           );
           return;
@@ -13292,13 +13238,13 @@ function AppContent({
           spawn: (prompt, sessionId2, configOverride) => {
             setPendingStartupDiagnostics(null);
             setStartupFailure(null);
-            if (!isServerRunning && runtimeError) {
+            if (!isServerRunning && runtimeError2) {
               setStartupFailure({
-                message: runtimeError.message,
-                failureCode: runtimeError.code === "socket_path_too_long" ? "socket_path_too_long" : "hook_server_unavailable"
+                message: runtimeError2.message,
+                failureCode: runtimeError2.code === "socket_path_too_long" ? "socket_path_too_long" : "hook_server_unavailable"
               });
               emitNotification(
-                `Athena failed to start ${harnessLabel}: ${runtimeError.message}`,
+                `Athena failed to start ${harnessLabel}: ${runtimeError2.message}`,
                 `${harnessLabel} Startup Error`
               );
               return Promise.resolve();
@@ -13326,7 +13272,7 @@ function AppContent({
       spawnHarness,
       currentSessionId,
       isServerRunning,
-      runtimeError,
+      runtimeError2,
       exit,
       clearScreen,
       onShowSessions,
@@ -13345,7 +13291,7 @@ function AppContent({
   const isHarnessRunningRef = useRef16(isHarnessRunning);
   isHarnessRunningRef.current = isHarnessRunning;
   const submitDispatchAsTurnRef = useRef16(null);
-  const submitDispatchAsTurn = useCallback18(
+  const submitDispatchAsTurn = useCallback19(
     (payload) => {
       const text = payload.inbound.text;
       if (text.trim().length === 0) return;
@@ -13438,17 +13384,18 @@ function AppContent({
     submitSearchQuery: (query, firstMatchIndex) => dispatchUi({ type: "submit_search_query", query, firstMatchIndex }),
     submitPromptOrSlashCommand,
     displayedEntriesRef: displayedFeedEntriesRef,
+    getEntrySearchText,
     getSelectedCommand: () => getSelectedCommandRef.current()
   });
   const visualInputRows = Math.max(2, inputRows);
   const shellInputRef = useRef16(null);
   getSelectedCommandRef.current = () => shellInputRef.current?.getSelectedCommand();
   const { back: handleHistoryBack, forward: handleHistoryForward } = inputHistory;
-  const stableSetInputValue = useCallback18(
+  const stableSetInputValue = useCallback19(
     (v) => setInputValueRef.current(v),
     [setInputValueRef]
   );
-  const stableGetInputValue = useCallback18(() => inputValueRef.current, []);
+  const stableGetInputValue = useCallback19(() => inputValueRef.current, []);
   const provisionalFooterRows = 1;
   const hasMessages = useMemo17(
     () => filteredEntries.some((e) => classifyEntry(e) !== "feed"),
@@ -13631,29 +13578,29 @@ function AppContent({
     runSummaries,
     staticHighWaterMark
   });
-  const cycleFocus = useCallback18(
+  const cycleFocus = useCallback19(
     () => dispatchUi({ type: "cycle_focus" }),
     [dispatchUi]
   );
-  const handlePermissionDecision = useCallback18(
+  const handlePermissionDecision = useCallback19(
     (decision) => {
       if (!currentPermissionRequest) return;
       resolvePermission(currentPermissionRequest.request_id, decision);
     },
     [currentPermissionRequest, resolvePermission]
   );
-  const handleQuestionAnswer = useCallback18(
+  const handleQuestionAnswer = useCallback19(
     (answers) => {
       if (!currentQuestionRequest?.cause?.hook_request_id) return;
       resolveQuestion(currentQuestionRequest.cause.hook_request_id, answers);
     },
     [currentQuestionRequest, resolveQuestion]
   );
-  const handleQuestionSkip = useCallback18(() => {
+  const handleQuestionSkip = useCallback19(() => {
     if (!currentQuestionRequest?.cause?.hook_request_id) return;
     resolveQuestion(currentQuestionRequest.cause.hook_request_id, {});
   }, [currentQuestionRequest, resolveQuestion]);
-  const handleDiagnosticsDecision = useCallback18(
+  const handleDiagnosticsDecision = useCallback19(
     (decision) => {
       const pending = pendingStartupDiagnostics;
       setPendingStartupDiagnostics(null);
@@ -13705,7 +13652,7 @@ function AppContent({
       }
     }
   });
-  const showToast = useCallback18((msg) => {
+  const showToast = useCallback19((msg) => {
     if (toastTimerRef.current) clearTimeout(toastTimerRef.current);
     setToastMessage(msg);
     toastTimerRef.current = setTimeout(() => setToastMessage(null), 1500);
@@ -13715,7 +13662,7 @@ function AppContent({
       if (toastTimerRef.current) clearTimeout(toastTimerRef.current);
     };
   }, []);
-  const yankAtCursor = useCallback18(() => {
+  const yankAtCursor = useCallback19(() => {
     const entry = displayedFeedEntriesRef.current.find(
       (e) => e.id === resolvedUiState.feedCursorId
     );
@@ -13724,7 +13671,7 @@ function AppContent({
     copyToClipboard(content);
     showToast("Copied to clipboard!");
   }, [resolvedUiState.feedCursorId, showToast, theme]);
-  const yankMessageAtCursor = useCallback18(() => {
+  const yankMessageAtCursor = useCallback19(() => {
     const entry = messageEntries.at(resolvedUiState.messageCursorIndex);
     if (!entry) return;
     const text = messageText(entry);
@@ -13884,7 +13831,7 @@ function AppContent({
     () => source_default.hex(theme.inputPrompt).bold(inputPrefix),
     [inputPrefix, theme.inputPrompt]
   );
-  const withBorderEdges = useCallback18(
+  const withBorderEdges = useCallback19(
     (line) => {
       if (line.length < 2) return line;
       const first = line.charAt(0);
@@ -13893,14 +13840,14 @@ function AppContent({
     },
     [border]
   );
-  const withSectionEdges = useCallback18(
+  const withSectionEdges = useCallback19(
     (content) => {
       const glyphs = frameGlyphs(useAscii);
       return `${border(glyphs.teeLeft)}${content}${border(glyphs.teeRight)}`;
     },
     [border, useAscii]
   );
-  const wrapFrameLine = useCallback18(
+  const wrapFrameLine = useCallback19(
     (line) => withBorderEdges(frameLine(line)),
     [withBorderEdges, frameLine]
   );
@@ -14495,7 +14442,7 @@ function App({
     runtimeState.modelName,
     runtimeState.workflowRef
   ]);
-  const handleProfilerRender = useCallback18(
+  const handleProfilerRender = useCallback19(
     (id, phaseName, actualDuration, baseDuration, startTime, commitTime) => {
       logReactCommit(
         id,
@@ -14508,20 +14455,20 @@ function App({
     },
     []
   );
-  const handleSessionSelect = useCallback18((sessionId) => {
+  const handleSessionSelect = useCallback19((sessionId) => {
     const meta = getSessionMeta(sessionId);
     const adapterIds = meta?.adapterSessionIds ?? [];
     const lastAdapterId = adapterIds[adapterIds.length - 1];
     setAthenaSessionId(sessionId);
     setPhase({ type: "main", initialSessionId: lastAdapterId });
   }, []);
-  const handleSessionCancel = useCallback18(() => {
+  const handleSessionCancel = useCallback19(() => {
     setPhase({ type: "main" });
   }, []);
-  const handleShowSessions = useCallback18(() => {
+  const handleShowSessions = useCallback19(() => {
     setPhase({ type: "session-select" });
   }, []);
-  const handleShowSetup = useCallback18(() => {
+  const handleShowSetup = useCallback19(() => {
     setPhase({ type: "setup" });
   }, []);
   const [sessions, setSessions] = useState18([]);
@@ -14539,7 +14486,7 @@ function App({
     }, 0);
     return () => clearTimeout(timer);
   }, [projectDir, phase.type]);
-  const refreshRuntime = useCallback18(() => {
+  const refreshRuntime = useCallback19(() => {
     try {
       const refreshed = bootstrapRuntimeConfig({
         projectDir,
@@ -14564,7 +14511,7 @@ function App({
       console.error(`Error: ${error.message}`);
     }
   }, [projectDir, pluginFlags, isolationPreset, verbose]);
-  const handleSetupComplete = useCallback18(
+  const handleSetupComplete = useCallback19(
     (setupResult) => {
       setActiveTheme(resolveTheme(setupResult.theme));
       refreshRuntime();
@@ -14572,10 +14519,10 @@ function App({
     },
     [refreshRuntime]
   );
-  const handleWorkflowSelected = useCallback18(() => {
+  const handleWorkflowSelected = useCallback19(() => {
     refreshRuntime();
   }, [refreshRuntime]);
-  const handleModelSelected = useCallback18(() => {
+  const handleModelSelected = useCallback19(() => {
     refreshRuntime();
   }, [refreshRuntime]);
   if (phase.type === "setup") {
@@ -14801,7 +14748,7 @@ var tasksCommand = {
 };
 
 // src/app/commands/builtins/setup.ts
-var setup = {
+var setup2 = {
   name: "setup",
   description: "Re-run the setup wizard",
   category: "ui",
@@ -14809,7 +14756,7 @@ var setup = {
     ctx.showSetup();
   }
 };
-var setup_default = setup;
+var setup_default = setup2;
 
 // src/app/commands/builtins/telemetry.ts
 var telemetryCommand = {
@@ -15989,6 +15936,8 @@ Subcommands:
             so the daemon starts automatically on login.
   doctor    Verify pairing health. With --runner <id>, also confirms the
             runner is bound to this instance.
+  list      Print the local attachment mirror (the runners the dashboard
+            reported as bound to this instance at the last pair/refresh).
   console enable <runnerId>
             Configure the console channel for a runner (opinionated;
             writes the sidecar and reloads the gateway).
@@ -16015,7 +15964,7 @@ var cachedVersion = null;
 function readPackageVersion() {
   if (cachedVersion !== null) return cachedVersion;
   try {
-    const injected = "0.4.2";
+    const injected = "0.4.5";
     if (typeof injected === "string" && injected.length > 0) {
       cachedVersion = injected;
       return cachedVersion;
@@ -16058,6 +16007,9 @@ async function runDashboardCommand(input, deps = {}) {
   const writeConfig = deps.writeConfig ?? ((c2) => writeDashboardClientConfig(c2));
   const removeConfig = deps.removeConfig ?? (() => removeDashboardClientConfig());
   const configPath = deps.configPath ?? (() => dashboardClientConfigPath());
+  const readMirror = deps.readMirror ?? (() => readAttachmentMirror());
+  const writeMirror = deps.writeMirror ?? ((m) => writeAttachmentMirror(m));
+  const removeMirror = deps.removeMirror ?? (() => removeAttachmentMirror());
   const packageVersion = deps.packageVersion ?? readPackageVersion();
   const { subcommand, subcommandArgs, flags } = input;
   if (!subcommand || subcommand === "help" || subcommand === "--help") {
@@ -16137,7 +16089,7 @@ async function runDashboardCommand(input, deps = {}) {
         `dashboard pair: cli version ${packageVersion} is older than the dashboard's required >=${parsed.requiredCliVersion}.`
       );
       logError(
-        "dashboard pair: upgrade with `npm i -g @athenaflow/cli` then re-run pair."
+        "dashboard pair: upgrade with `npm i -g @drisp/cli` then re-run pair."
       );
       return 1;
     }
@@ -16149,6 +16101,22 @@ async function runDashboardCommand(input, deps = {}) {
       pairedAt: now()
     };
     writeConfig(config);
+    try {
+      writeMirror({
+        instanceId: parsed.instanceId,
+        fetchedAt: now(),
+        attachments: (parsed.runners ?? []).map((r) => ({
+          runnerId: r.runnerId,
+          ...r.name !== void 0 ? { name: r.name } : {},
+          ...r.executionTarget !== void 0 ? { executionTarget: r.executionTarget } : {},
+          ...r.remoteInstanceId !== void 0 ? { remoteInstanceId: r.remoteInstanceId } : {}
+        }))
+      });
+    } catch (err) {
+      logError(
+        `dashboard pair: failed to write attachment mirror: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     const daemonStart = await (deps.startRuntimeDaemon ?? defaultStartRuntimeDaemon)({
       log: (msg) => logOut(msg)
     });
@@ -16866,14 +16834,22 @@ async function runDashboardCommand(input, deps = {}) {
         return 1;
       }
       const dir = (deps.channelDir ?? channelSidecarDir)();
+      const target = path7.join(dir, `console-${runnerId}.json`);
+      const legacyTarget = path7.join(dir, "console.json");
       let previousBroker;
-      const target = path7.join(dir, "console.json");
       try {
         const existing = JSON.parse(fs7.readFileSync(target, "utf-8"));
         if (typeof existing.broker_url === "string") {
           previousBroker = existing.broker_url;
         }
       } catch {
+        try {
+          const legacy = JSON.parse(fs7.readFileSync(legacyTarget, "utf-8"));
+          if (typeof legacy.broker_url === "string" && legacy.runner_id === runnerId) {
+            previousBroker = legacy.broker_url;
+          }
+        } catch {
+        }
       }
       try {
         fs7.mkdirSync(dir, { recursive: true, mode: 448 });
@@ -16884,6 +16860,8 @@ async function runDashboardCommand(input, deps = {}) {
         return 1;
       }
       const payload = {
+        kind: "console",
+        instance_id: `console:${runnerId}`,
         broker_url: brokerUrl,
         runner_id: runnerId,
         dashboard_config: true
@@ -16904,6 +16882,13 @@ async function runDashboardCommand(input, deps = {}) {
         );
         return 1;
       }
+      try {
+        const legacy = JSON.parse(fs7.readFileSync(legacyTarget, "utf-8"));
+        if (legacy.runner_id === runnerId) {
+          fs7.unlinkSync(legacyTarget);
+        }
+      } catch {
+      }
       const reload = await (deps.reloadGatewayChannels ?? defaultReloadGatewayChannels)();
       if (flags.json) {
         logOut(
@@ -16938,6 +16923,72 @@ async function runDashboardCommand(input, deps = {}) {
     );
     return 2;
   }
+  if (subcommand === "list") {
+    if (subcommandArgs.length > 0) {
+      logError(`dashboard list: unexpected argument ${subcommandArgs[0]}`);
+      return 2;
+    }
+    const config = readConfig2();
+    if (!config) {
+      if (flags.json) {
+        logOut(JSON.stringify({ ok: false, paired: false }));
+      } else {
+        logError(
+          'dashboard list: not paired. Run "drisp dashboard pair" first.'
+        );
+      }
+      return 1;
+    }
+    const mirror = readMirror();
+    if (!mirror) {
+      if (flags.json) {
+        logOut(
+          JSON.stringify({
+            ok: true,
+            paired: true,
+            instanceId: config.instanceId,
+            attachments: [],
+            mirror: null
+          })
+        );
+      } else {
+        logOut(
+          `dashboard list: paired as ${config.instanceId}, no attachment mirror on disk.`
+        );
+        logOut(
+          "dashboard list: re-run `drisp dashboard pair` to refresh the mirror."
+        );
+      }
+      return 0;
+    }
+    if (flags.json) {
+      logOut(
+        JSON.stringify({
+          ok: true,
+          paired: true,
+          instanceId: mirror.instanceId,
+          fetchedAt: mirror.fetchedAt,
+          attachments: mirror.attachments
+        })
+      );
+    } else {
+      logOut(`dashboard: instance ${mirror.instanceId}`);
+      logOut(
+        `dashboard: mirror fetched ${new Date(mirror.fetchedAt).toISOString()}`
+      );
+      if (mirror.attachments.length === 0) {
+        logOut("dashboard: no runners attached.");
+      } else {
+        logOut(`dashboard: ${mirror.attachments.length} runner(s) attached:`);
+        for (const a of mirror.attachments) {
+          const label = a.name ? `${a.name} (${a.runnerId})` : a.runnerId;
+          const target = a.executionTarget ? ` [${a.executionTarget}]` : "";
+          logOut(`  - ${label}${target}`);
+        }
+      }
+    }
+    return 0;
+  }
   if (subcommand === "unpair") {
     if (subcommandArgs.length > 0) {
       logError(`dashboard unpair: unexpected argument ${subcommandArgs[0]}`);
@@ -17009,6 +17060,7 @@ async function runDashboardCommand(input, deps = {}) {
       }
     }
     removeConfig();
+    removeMirror();
     if (flags.json) {
       logOut(
         JSON.stringify({
@@ -18473,7 +18525,7 @@ Available commands: ${[...KNOWN_COMMANDS].join(", ")}`
         await exitWith(1);
         return;
       }
-      const { default: WorkflowInstallWizard } = await import("./WorkflowInstallWizard-NDWLVIFI.js");
+      const { default: WorkflowInstallWizard } = await import("./WorkflowInstallWizard-2MC5A7W4.js");
       const { waitUntilExit } = render(
         /* @__PURE__ */ jsx25(
           WorkflowInstallWizard,