paseo-plugin-chat-view 0.0.0-stage → 0.1.0

package/client/activity/detail/texts.tsx

@@ -0,0 +1,42 @@
+import React from "react";
+import { Text } from "react-native";
+
+import { DetailRenderProps, HighlightedCodeBlock } from "./parts";
+
+/** Details that are text themselves: sub-agent runs, plain messages, and plans. */
+export function SubAgentDetail({ detail, theme, styles }: DetailRenderProps<"sub_agent">) {
+  return (
+    <>
+      {detail.subAgentType ? <Text style={styles.detailText}>{detail.subAgentType}</Text> : null}
+      {detail.description ? <Text style={styles.mutedText}>{detail.description}</Text> : null}
+      {detail.childSessionId ? (
+        <Text style={styles.mutedText}>Session {detail.childSessionId}</Text>
+      ) : null}
+      {detail.log ? (
+        <HighlightedCodeBlock
+          code={detail.log}
+          language="ansi"
+          label="Activity log"
+          styles={styles}
+          theme={theme}
+        />
+      ) : null}
+    </>
+  );
+}
+
+export function PlainTextDetail({ detail, styles }: DetailRenderProps<"plain_text">) {
+  return (
+    <Text selectable style={styles.detailText}>
+      {detail.text ?? ""}
+    </Text>
+  );
+}
+
+export function PlanDetail({ detail, styles }: DetailRenderProps<"plan">) {
+  return (
+    <Text selectable style={styles.detailText}>
+      {detail.text}
+    </Text>
+  );
+}

package/client/activity/disclosure.ts

@@ -0,0 +1,49 @@
+import { useMemo, useSyncExternalStore } from "react";
+import { usePaseo } from "@getpaseo/plugin/client";
+import type { PaseoApi } from "@getpaseo/client";
+
+function createDisclosure() {
+  let expanded: boolean | undefined;
+  const listeners = new Set<() => void>();
+  return {
+    snapshot: () => expanded,
+    subscribe(listener: () => void) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    set(value: boolean) {
+      if (expanded === value) return;
+      expanded = value;
+      for (const listener of listeners) listener();
+    },
+  };
+}
+let disclosures = new WeakMap<PaseoApi, Map<string, ReturnType<typeof createDisclosure>>>();
+export function cleanupActivityDisclosure() {
+  disclosures = new WeakMap();
+}
+
+/** Retain explicit choices across virtualized row remounts, scoped to the host connection. */
+export function useActivityDisclosure(agentId: string, rowId: string) {
+  const paseo = usePaseo();
+  const state = useMemo(() => {
+    let rows = disclosures.get(paseo);
+    if (!rows) {
+      rows = new Map();
+      disclosures.set(paseo, rows);
+    }
+    const key = JSON.stringify([agentId, rowId]);
+    let row = rows.get(key);
+    if (!row) {
+      row = createDisclosure();
+      rows.set(key, row);
+    }
+    return row;
+  }, [paseo, agentId, rowId]);
+  return [
+    useSyncExternalStore(state.subscribe, state.snapshot, state.snapshot),
+    state.set,
+  ] as const;
+}

package/client/activity/dom.test.ts

@@ -0,0 +1,52 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { setupCompactActivityStyles } from "./dom";
+
+vi.mock("react-native", () => ({ Platform: { OS: "web" } }));
+
+/** The activity stylesheet only touches `document.body` and `createElement`, so the fake stays minimal. */
+class StyleNode {
+  textContent = "";
+  isConnected = true;
+  parentElement: StyleNode | null = null;
+  children: StyleNode[] = [];
+  attributes = new Map<string, string>();
+  setAttribute(name: string, value: string) {
+    this.attributes.set(name, value);
+  }
+  getAttribute(name: string) {
+    return this.attributes.get(name) ?? null;
+  }
+  appendChild(child: StyleNode) {
+    this.children.push(child);
+    child.parentElement = this;
+  }
+  remove() {
+    this.isConnected = false;
+    if (this.parentElement)
+      this.parentElement.children = this.parentElement.children.filter((child) => child !== this);
+  }
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+it("injects compact message and paragraph styling rules and removes them on cleanup", () => {
+  const body = new StyleNode();
+  vi.stubGlobal("document", { body, createElement: () => new StyleNode() });
+  const remove = setupCompactActivityStyles();
+  const styleNode = body.children.find(
+    (child) => child.getAttribute("data-plugin") === "chat-view-activity",
+  );
+  expect(styleNode).toBeDefined();
+  expect(styleNode?.textContent).toContain('data-testid="assistant-message"');
+  expect(styleNode?.textContent).toContain('data-paseo-markdown-tag="p"');
+  expect(styleNode?.textContent).toContain("margin-bottom: 8px !important;");
+  expect(styleNode?.textContent).toContain("margin-bottom: 0 !important;");
+
+  remove();
+  expect(styleNode?.isConnected).toBe(false);
+  expect(
+    body.children.some((child) => child.getAttribute("data-plugin") === "chat-view-activity"),
+  ).toBe(false);
+});

package/client/activity/dom.ts

@@ -0,0 +1,138 @@
+import { Platform } from "react-native";
+import type { Document, Element, Window } from "../dom";
+
+// Compact-activity DOM access: the scoped stylesheet tightening the host conversation rhythm, and
+// the scroll-into-view bridge the detail panels use. Neither is observable from the sticky
+// viewport module, so the two features cannot grow entangled selectors.
+declare const document: Document;
+declare const window: Window;
+
+/** Scoped CSS also applies to rows mounted later by the virtual list. */
+export function setupCompactActivityStyles(): () => void {
+  if (Platform.OS !== "web" || typeof document === "undefined") return () => {};
+  const style = document.createElement("style");
+  style.setAttribute("data-plugin", "chat-view-activity");
+  style.textContent = `
+    /* 活动折叠组间距优化 */
+    [data-testid="agent-chat-scroll"] [data-history-row-id]:has([data-testid="folded-activity-group"]) > div {
+      margin-top: 1px !important;
+      margin-bottom: 2px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-history-row-id]:has([data-testid="folded-activity-follower"]) > div {
+      margin-bottom: 0 !important;
+    }
+
+    /* 用户提问气泡底部间距适度紧凑化 */
+    [data-testid="agent-chat-scroll"] [data-history-row-id]:has([data-testid="user-message"]) > div {
+      margin-bottom: 8px !important;
+    }
+
+    /* 助手消息容器垂直 padding 紧凑化，消除原生默认上下 12px 的过大留白 */
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] {
+      padding-top: 4px !important;
+      padding-bottom: 4px !important;
+    }
+
+    /* 助手消息直接子块容器间距优化 */
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] > div {
+      margin-bottom: 8px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] > div:last-child {
+      margin-bottom: 0 !important;
+    }
+
+    /* Markdown 段落间距紧凑优化与专业美化，消除末尾段落多余的底部留白 */
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] :is(p, [data-paseo-markdown-tag="p"]) {
+      margin-top: 0 !important;
+      margin-bottom: 8px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] :is(p, [data-paseo-markdown-tag="p"]):last-child {
+      margin-bottom: 0 !important;
+    }
+
+    /* 列表块及列表项间距优化 */
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] :is([data-paseo-markdown-tag="ul"], [data-paseo-markdown-tag="ol"]) {
+      margin-top: 4px !important;
+      margin-bottom: 8px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] :is([data-paseo-markdown-tag="ul"], [data-paseo-markdown-tag="ol"]):last-child {
+      margin-bottom: 0 !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="li"] {
+      margin-bottom: 3px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="li"]:last-child {
+      margin-bottom: 0 !important;
+    }
+
+    /* 代码块与引用块间距紧凑化 */
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="pre"] {
+      margin-top: 6px !important;
+      margin-bottom: 8px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="pre"]:first-child {
+      margin-top: 0 !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="pre"]:last-child {
+      margin-bottom: 0 !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="blockquote"] {
+      margin-top: 6px !important;
+      margin-bottom: 8px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="blockquote"]:first-child {
+      margin-top: 0 !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="blockquote"]:last-child {
+      margin-bottom: 0 !important;
+    }
+
+    /* 标题间距优化 */
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="h1"],
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="h2"] {
+      margin-top: 14px !important;
+      margin-bottom: 6px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] :is([data-paseo-markdown-tag="h3"], [data-paseo-markdown-tag="h4"], [data-paseo-markdown-tag="h5"], [data-paseo-markdown-tag="h6"]) {
+      margin-top: 10px !important;
+      margin-bottom: 4px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] :is([data-paseo-markdown-tag="h1"], [data-paseo-markdown-tag="h2"], [data-paseo-markdown-tag="h3"], [data-paseo-markdown-tag="h4"], [data-paseo-markdown-tag="h5"], [data-paseo-markdown-tag="h6"]):first-child {
+      margin-top: 0 !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] :is([data-paseo-markdown-tag="h1"], [data-paseo-markdown-tag="h2"], [data-paseo-markdown-tag="h3"], [data-paseo-markdown-tag="h4"], [data-paseo-markdown-tag="h5"], [data-paseo-markdown-tag="h6"]):last-child {
+      margin-bottom: 0 !important;
+    }
+
+    /* 表格与水平分割线间距紧凑化 */
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="table"] {
+      margin-top: 6px !important;
+      margin-bottom: 8px !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="table"]:last-child {
+      margin-bottom: 0 !important;
+    }
+    [data-testid="agent-chat-scroll"] [data-testid="assistant-message"] [data-paseo-markdown-tag="hr"] {
+      margin-top: 8px !important;
+      margin-bottom: 8px !important;
+    }
+
+    /* 图片尺寸自适应约束 */
+    [data-testid="agent-chat-scroll"] [role="img"]:not([role="dialog"] *):not([data-testid="attachment-lightbox"] *) {
+      max-width: min(440px, 100%) !important; max-height: 320px !important; align-self: flex-start !important;
+    }
+    [data-testid="agent-chat-scroll"] img:not([role="dialog"] *):not([data-testid="attachment-lightbox"] *) {
+      max-width: 100% !important; max-height: 320px !important; width: auto !important; height: auto !important; object-fit: contain !important;
+    }
+  `;
+  document.body.appendChild(style);
+  return () => style.remove();
+}
+
+export function scrollActivityIntoView(anchor: unknown): void {
+  if (Platform.OS !== "web" || typeof window === "undefined") return;
+  const element = anchor as Element | null;
+  window.requestAnimationFrame(() => {
+    if (element?.isConnected) element.scrollIntoView?.({ block: "nearest", behavior: "auto" });
+  });
+}

package/client/activity/group-store.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import type { AgentTimelineItem } from "@getpaseo/protocol/agent-types";
+import {
+  buildActivityGroups,
+  formatGroupSummary,
+  updateGroupStats,
+  type ActivityEntry,
+} from "./group-store";
+const entry = (seq: number, item: AgentTimelineItem, seqEnd = seq): ActivityEntry => ({
+  item,
+  seqStart: seq,
+  seqEnd,
+  timestamp: new Date(seq * 1000).toISOString(),
+});
+const tool = (status: "running" | "completed" = "completed"): AgentTimelineItem => ({
+  type: "tool_call",
+  callId: "shell-1",
+  name: "exec_command",
+  status,
+  error: null,
+  detail: { type: "shell", command: "pwd", cwd: "/tmp" },
+});
+
+describe("activity grouping", () => {
+  it("folds contiguous thoughts and tools, preserving visible message boundaries", () => {
+    const groups = buildActivityGroups([
+      entry(1, { type: "user_message", text: "question" }),
+      entry(2, { type: "reasoning", text: "thinking" }),
+      entry(3, tool()),
+      entry(4, { type: "assistant_message", text: "answer" }),
+      entry(5, { type: "reasoning", text: "next thought" }),
+    ]);
+    const first = groups.get("reasoning:2000")!;
+    expect(first.isLeader).toBe(true);
+    expect(groups.get("tool:shell-1")!.isLeader).toBe(false);
+    expect(first.group.items).toHaveLength(2);
+    expect(first.group.isFinished).toBe(true);
+    expect(formatGroupSummary(first.group)).toBe("Thought · Ran 1 command");
+    expect(groups.get("reasoning:5000")!.group).not.toBe(first.group);
+  });
+  it("uses the latest lifecycle output without counting a call twice", () => {
+    const entries = [entry(1, tool("running")), entry(2, tool(), 3)];
+    const group = buildActivityGroups(entries).get("tool:shell-1")!.group;
+    expect(group.items).toHaveLength(1);
+    expect(group.commandCount).toBe(1);
+    expect(group.isRunning).toBe(false);
+    expect(group.items[0]!.toolCallData!.status).toBe("completed");
+    expect(buildActivityGroups(entries).get("tool:shell-1")!.group).toEqual(group);
+  });
+  it("keeps separate histories independent even with overlapping identities", () => {
+    const first = buildActivityGroups([entry(1, tool("running"))]);
+    const second = buildActivityGroups([entry(1, tool())]);
+    expect(first.get("tool:shell-1")!.group.isRunning).toBe(true);
+    expect(second.get("tool:shell-1")!.group.isRunning).toBe(false);
+  });
+  it("keeps speak messages visible and splits groups around them", () => {
+    const groups = buildActivityGroups([
+      entry(1, { type: "reasoning", text: "before" }),
+      entry(2, {
+        type: "tool_call",
+        callId: "speak",
+        name: "speak",
+        status: "completed",
+        error: null,
+        detail: { type: "unknown", input: "hello", output: null },
+      }),
+      entry(3, tool()),
+    ]);
+    expect(groups.has("tool:speak")).toBe(false);
+    expect(groups.get("tool:shell-1")!.isLeader).toBe(true);
+  });
+});
+
+it("recomputes counters from the items when a call changes in place", () => {
+  const group = buildActivityGroups([entry(1, tool("running"))]).get("tool:shell-1")!.group;
+  expect(group.isRunning).toBe(true);
+  expect(group.commandCount).toBe(1);
+  expect(group.hasError).toBe(false);
+
+  group.items[0]!.toolCallData!.status = "failed";
+  updateGroupStats(group);
+
+  expect(group.isRunning).toBe(false);
+  expect(group.hasError).toBe(true);
+  expect(group.commandCount).toBe(1);
+  updateGroupStats(group);
+  expect(group.commandCount).toBe(1);
+});
+
+it("keeps a sealed group from running again after a rescan", () => {
+  const group = buildActivityGroups([
+    entry(1, tool("running")),
+    entry(2, {
+      type: "assistant_message",
+      text: "answer",
+    }),
+  ]).get("tool:shell-1")!.group;
+  expect(group.isFinished).toBe(true);
+  updateGroupStats(group);
+  expect(group.isRunning).toBe(false);
+});
+
+it("keeps distinct sequence identities when two thoughts share a timestamp", () => {
+  const rows = [
+    entry(1, { type: "reasoning", text: "first" }),
+    entry(2, { type: "assistant_message", text: "boundary" }),
+    { ...entry(3, { type: "reasoning", text: "second" }), timestamp: new Date(1000).toISOString() },
+  ];
+  // Timestamp-only lookup is ambiguous; retain separate sequence keys for text matching.
+  const groups = buildActivityGroups(rows);
+  expect(groups.get("reasoning:1000")).toBeUndefined();
+  expect(groups.get("reasoning:1000:1")?.group).not.toBe(groups.get("reasoning:1000:3")?.group);
+});
+
+it("keeps a reasoning identity stable while its text streams", () => {
+  const short = buildActivityGroups([entry(7, { type: "reasoning", text: "think" })]).get(
+    "reasoning:7000",
+  )!;
+  const streamed = buildActivityGroups([
+    entry(7, { type: "reasoning", text: "thinking out loud" }, 9),
+  ]).get("reasoning:7000")!;
+  // The row key must survive growth, otherwise React remounts the row on every token.
+  expect(streamed.group.items[0]!.id).toBe(short.group.items[0]!.id);
+  expect(streamed.group.leaderId).toBe(short.group.leaderId);
+  expect(streamed.group.items[0]!.reasoningData!.text).toBe("thinking out loud");
+});

package/client/activity/group-store.ts

@@ -0,0 +1,265 @@
+import type { AgentTimelineItem } from "@getpaseo/protocol/agent-types";
+import { createReasoningData, createToolCallData } from "../../shared/activity/timeline";
+import type { ReasoningItemData, ToolCallItemData } from "../../shared/activity/timeline";
+
+export interface GroupItemData {
+  id: string;
+  type: "reasoning" | "tool_call";
+  timestamp: number;
+  reasoningData?: ReasoningItemData;
+  toolCallData?: ToolCallItemData;
+}
+
+export interface TurnGroup {
+  turnIndex: number;
+  agentId?: string;
+  leaderId: string;
+  items: GroupItemData[];
+  hasReasoning: boolean;
+  commandCount: number;
+  editCount: number;
+  readCount: number;
+  searchCount: number;
+  otherToolCount: number;
+  isRunning: boolean;
+  isFinished?: boolean;
+  hasError: boolean;
+  startedAt: number;
+  completedAt?: number;
+}
+
+export function isFileEditAction(tc: ToolCallItemData): boolean {
+  if (tc.detail && typeof tc.detail === "object") {
+    const detailType = (tc.detail as { type?: string }).type;
+    if (
+      detailType === "edit" ||
+      detailType === "write" ||
+      detailType === "patch" ||
+      detailType === "create"
+    ) {
+      return true;
+    }
+    if (detailType === "read") {
+      return false;
+    }
+  }
+
+  if (tc.presentation.diffStats) {
+    return true;
+  }
+
+  const label = tc.presentation.label.toLowerCase();
+  if (
+    label.includes("write") ||
+    label.includes("edit") ||
+    label.includes("patch") ||
+    label.includes("create")
+  ) {
+    return true;
+  }
+
+  const name = tc.name.toLowerCase();
+  if (
+    name.includes("write") ||
+    name.includes("edit") ||
+    name.includes("replace") ||
+    name.includes("patch") ||
+    name.includes("create")
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+export function createActivityGroup(
+  turnIndex: number,
+  leaderId: string,
+  startedAt: number,
+  items: GroupItemData[] = [],
+): TurnGroup {
+  return {
+    turnIndex,
+    leaderId,
+    items,
+    hasReasoning: false,
+    commandCount: 0,
+    editCount: 0,
+    readCount: 0,
+    searchCount: 0,
+    otherToolCount: 0,
+    isRunning: false,
+    hasError: false,
+    startedAt,
+  };
+}
+
+/**
+ * Fold one item into the running totals. Build visits every entry exactly once, so accumulating per
+ * item keeps grouping linear instead of rescanning the whole group per entry. Returns true when the
+ * item is still active, which the caller tracks to derive isRunning.
+ */
+function accumulateItemStats(group: TurnGroup, item: GroupItemData): boolean {
+  if (item.type === "reasoning") {
+    group.hasReasoning = true;
+    return item.reasoningData?.phase === "streaming";
+  }
+  if (item.type !== "tool_call" || !item.toolCallData) return false;
+  const tc = item.toolCallData;
+  if (tc.status === "failed" || tc.errorText) group.hasError = true;
+  const cat = tc.presentation.category;
+  if (cat === "shell") {
+    group.commandCount++;
+  } else if (cat === "file") {
+    if (isFileEditAction(tc)) {
+      group.editCount++;
+    } else {
+      group.readCount++;
+    }
+  } else if (cat === "search") {
+    group.searchCount++;
+  } else {
+    group.otherToolCount++;
+  }
+  return tc.status === "running";
+}
+
+/** Recompute every counter from the items, so a group whose item changed in place stays consistent. */
+export function updateGroupStats(group: TurnGroup): void {
+  group.hasReasoning = false;
+  group.commandCount = 0;
+  group.editCount = 0;
+  group.readCount = 0;
+  group.searchCount = 0;
+  group.otherToolCount = 0;
+  group.hasError = false;
+  let activeCount = 0;
+  for (const item of group.items) {
+    if (accumulateItemStats(group, item)) activeCount++;
+  }
+  group.isRunning = group.isFinished ? false : activeCount > 0;
+}
+
+export function formatGroupSummary(group: TurnGroup): string {
+  const parts: string[] = [];
+
+  if (group.hasReasoning) {
+    parts.push("Thought");
+  }
+  if (group.commandCount > 0) {
+    parts.push(`Ran ${group.commandCount} command${group.commandCount > 1 ? "s" : ""}`);
+  }
+  if (group.editCount > 0) {
+    parts.push(`Edited ${group.editCount} file${group.editCount > 1 ? "s" : ""}`);
+  }
+  if (group.readCount > 0) {
+    parts.push(`Read ${group.readCount} file${group.readCount > 1 ? "s" : ""}`);
+  }
+  if (group.searchCount > 0) {
+    parts.push(`Searched ${group.searchCount} time${group.searchCount > 1 ? "s" : ""}`);
+  }
+  if (group.otherToolCount > 0) {
+    parts.push(`Called ${group.otherToolCount} tool${group.otherToolCount > 1 ? "s" : ""}`);
+  }
+
+  return parts.length > 0 ? parts.join(" · ") : "Activity";
+}
+
+export interface ActivityEntry {
+  item: AgentTimelineItem;
+  timestamp: string;
+  seqStart: number;
+  seqEnd: number;
+}
+
+/**
+ * Identity must stay stable while streaming text grows: it becomes the React key of the rendered
+ * activity row, so embedding the reasoning text would remount the subtree on every token and
+ * restart reveal state, scroll anchoring and measured row heights.
+ */
+export function activityIdentity(item: AgentTimelineItem, timestamp: string): string {
+  return item.type === "tool_call"
+    ? `tool:${item.callId}`
+    : `${item.type}:${Date.parse(timestamp)}`;
+}
+
+/** Fold contiguous activity only: never move details across a visible message. */
+export function buildActivityGroups(entries: readonly ActivityEntry[]) {
+  const groups = new Map<string, { group: TurnGroup; isLeader: boolean; itemId: string }>();
+  let group: TurnGroup | undefined;
+  const tools = new Map<string, ActivityEntry>();
+  for (const entry of entries) {
+    if (entry.item.type !== "tool_call") continue;
+    const previous = tools.get(entry.item.callId);
+    if (!previous || previous.seqEnd < entry.seqEnd)
+      tools.set(entry.item.callId, {
+        ...entry,
+        seqStart: previous?.seqStart ?? entry.seqStart,
+      });
+  }
+  const ordered = entries.filter((entry) => entry.item.type !== "tool_call");
+  ordered.push(...tools.values());
+  ordered.sort((a, b) => a.seqStart - b.seqStart);
+  const identityCounts = new Map<string, number>();
+  for (const entry of ordered) {
+    if (entry.item.type !== "reasoning") continue;
+    const identity = activityIdentity(entry.item, entry.timestamp);
+    identityCounts.set(identity, (identityCounts.get(identity) ?? 0) + 1);
+  }
+  let activeCount = 0;
+  const seal = (finished: boolean) => {
+    if (!group) return;
+    group.isFinished = finished;
+    group.isRunning = !finished && activeCount > 0;
+    activeCount = 0;
+  };
+  for (const entry of ordered) {
+    const { item, timestamp } = entry;
+    const startedAt = Date.parse(timestamp);
+    // Visible messages end contiguous activity, so folded details never cross native prose.
+    if (item.type === "user_message") {
+      seal(true);
+      group = undefined;
+      continue;
+    }
+    if (item.type === "assistant_message") {
+      seal(true);
+      group = undefined;
+      continue;
+    }
+    const speak =
+      item.type === "tool_call" &&
+      item.name === "speak" &&
+      item.detail.type === "unknown" &&
+      typeof item.detail.input === "string" &&
+      item.detail.input.trim();
+    if (speak) {
+      seal(true);
+      group = undefined;
+      continue;
+    }
+    if (item.type !== "reasoning" && item.type !== "tool_call") {
+      seal(true);
+      group = undefined;
+      continue;
+    }
+    const identity = activityIdentity(item, timestamp);
+    // Sequence positions keep thought identities stable even when provider timestamps collide.
+    const id = item.type === "reasoning" ? `${identity}:${entry.seqStart}` : identity;
+    const lookup = (identityCounts.get(identity) ?? 0) > 1 ? id : identity;
+    if (!group) group = createActivityGroup(entry.seqStart, id, startedAt);
+    const groupItem: GroupItemData = {
+      id,
+      type: item.type,
+      timestamp: startedAt,
+      ...(item.type === "reasoning"
+        ? { reasoningData: createReasoningData(item, "complete") }
+        : { toolCallData: createToolCallData(item) }),
+    };
+    group.items.push(groupItem);
+    if (accumulateItemStats(group, groupItem)) activeCount++;
+    groups.set(lookup, { group, isLeader: group.leaderId === id, itemId: id });
+  }
+  seal(false);
+  return groups;
+}