pi-pretty-tui 0.1.8 → 0.2.1

package/README.md

@@ -6,11 +6,12 @@ A beautiful, polished TUI for the [Pi coding agent](https://pi.dev/).
 
 ## Features
 
-- **Collapsible tool activity:** instead of filling the conversation with individual tool calls, supported tools are collected into a single `Running(...)` row while work is in progress and a quiet `Done(...)` row when it finishes. Click the group to reveal its compact child calls, click any child for full details, and click the parent again to collapse everything.
+- **Collapsible activity timeline:** instead of filling the conversation with individual calls, thoughts, tools, and ordinary `info` notifications share one chronological activity stream. Work appears beneath a single `Running(...)` row and settles into a quiet `Done(...)` row. Parent rows count only tool calls and thoughts; expanding one reveals every ordered member with summaries retained above nested details. Thoughts and tools are peers: a turn that calls no tool still gets its own `Running(1 thought)` / `Done(1 thought)` parent row with the Thought as its child, so thinking is never dropped.
+- **Transient UI status:** one line above the editor shows direct Pi UI feedback such as Thinking/tool-output visibility changes. A newer UI status replaces it, and it disappears automatically after ten seconds without entering the transcript or session.
 - **Useful details on demand:** tool-aware summaries keep paths, commands, results, diffs, file previews, and live shell output concise without removing access to the original content.
 - **A cohesive visual finish:** rounded user messages and prompt input, theme-aware colors, a clear Markdown heading hierarchy, cleaner lists, and rounded syntax-highlighted code blocks make the entire TUI feel intentional. In fullscreen, each fenced code block also includes a native-feeling `[Copy]` control.
 
-Collapsible grouping covers Pi's built-in `read`, `bash`, `edit`, `write`, `grep`, `find`, and `ls` tools. Third-party tools keep their own rendering, and Pi's cursor, IME, autocomplete, mouse interaction, and tool execution behavior remain intact.
+Pi's built-in `read`, `bash`, `edit`, `write`, `grep`, `find`, and `ls` tools receive purpose-built compact views. Every third-party tool automatically receives a consistent compact row; opening it preserves its native renderer while removing conflicting terminal background colors. User and steering messages, compaction summaries, visible assistant text, warnings, errors, aborted/truncated responses, and displayed custom messages with a registered renderer create hard group boundaries. Pi's cursor, IME, autocomplete, mouse interaction, and tool execution behavior remain intact.
 
 ## Install
 
@@ -24,15 +25,23 @@ Pi may warn that built-in tools are being overridden. This is expected: pi-prett
 
 ## Working with tool calls
 
-Click a `Running(...)` or `Done(...)` row to keep it as a parent and reveal the tools beneath it. Click an individual child to toggle its complete view, or click the parent again to collapse the whole group. Press `Ctrl+O` at any time to use Pi's global expansion control for tool output and thinking content.
+Click a `Running(...)` or `Done(...)` row to keep it as a parent and reveal tools, completed `● thought` entries, and extension updates beneath it. Click an individual tool or thought to reveal nested details without replacing its summary, or click the parent again to collapse the whole group. Press `Ctrl+O` at any time to use Pi's global expansion control for all tool output and thinking content. Tool names use each definition's `label` verbatim, falling back to its raw `name`; pi-pretty-tui does not rename or title-case them.
 
-## Rendering modes
+Extension calls to `ctx.ui.notify(message, "info")` (or with the type omitted) join an existing thought/tool group in chronological order; without existing work they remain independent and never attach to a future group. Warnings and errors stay standalone, use yellow `⚠` and red `✕`, and are hard boundaries. Tool failures remain owned by their tool details. None of these extension notifications or errors appear in the transient UI-status line.
 
-The extension supports three persistent rendering modes: `clean` (default), `compact`, and `full`. Run `/pretty-tui` to choose one interactively, or use `/pretty-tui clean`, `/pretty-tui compact`, `/pretty-tui full`, and `/pretty-tui status` directly. The selection is stored in `~/.pi/agent/pretty-tui.json` or under the directory selected by `PI_CODING_AGENT_DIR`.
+Displayed custom messages without their own renderer use one generic accent-coloured `◇` Markdown presentation: they join current thought/tool work when it exists, otherwise remain independent, and preserve their session persistence. Messages with a registered renderer remain completely native and form hard boundaries. These decisions use only Pi's notification type and renderer presence—never extension names, custom message names, or content heuristics.
+
+Pi's direct internal `showStatus()` feedback is transient: it appears only in the status line above the editor, a newer status replaces it, and a ten-second timer removes it. It never enters the transcript or activity timeline and is cleared on reload. In clean mode, `Ctrl+T` leaves Pi's persisted Thinking setting unchanged and shows a short hint instead: thought details expand only when their own row is clicked, while `Ctrl+O` retains global activity expansion. In full and compact modes, `Ctrl+T` keeps Pi's native behaviour.
+
+## Settings and rendering modes
+
+Run `/pretty-tui` to open the extension settings. The `Enabled` switch persists whether pi-pretty-tui installs its render patches and built-in tool renderers. Changing it automatically runs Pi's official reload flow, so no manual `/reload` is needed. You can also use `/pretty-tui enable` and `/pretty-tui disable` directly. While disabled, the settings command remains available and Pi uses its native rendering.
+
+The extension supports three persistent rendering modes: `clean` (default), `compact`, and `full`. Choose one interactively, or use `/pretty-tui clean`, `/pretty-tui compact`, `/pretty-tui full`, and `/pretty-tui status` directly. Settings are stored in `~/.pi/agent/pretty-tui.json` or under the directory selected by `PI_CODING_AGENT_DIR`.
 
 ## Copy code blocks
 
-In fullscreen TUI mode, fenced Markdown code blocks include a clickable `[Copy]` control in the top rule:
+In fullscreen TUI mode, fenced Markdown code blocks in user and assistant transcript messages include a clickable `[Copy]` control in the top rule:
 
 ```sh
 pi --tui-mode fullscreen
@@ -49,11 +58,11 @@ npm install
 npm test
 ```
 
-The suite covers live and restored steering/compaction boundaries, parallel completion ownership, orphaned tool calls, duplicate-summary prevention, and fullscreen code-block copy hit regions. GitHub Actions runs the same checks on every push and pull request.
+The suite covers live and restored activity timelines, retries and terminal states, user/steering/compaction/native-renderer boundaries, ten-second UI-status replacement, stale-timer and flash cleanup on reload and shutdown, standalone severity styling, built-in and third-party tools, expandable thinking, parallel completion ownership, orphaned calls, duplicate-summary prevention, complete prototype-patch restoration, and fullscreen code-block copy hit regions. GitHub Actions runs the same checks on every push and pull request.
 
 ## Compatibility notice
 
-Tool rendering uses Pi's documented extension APIs. Thinking visibility and active-tool state follow Pi's built-in expansion and execution transitions through its exported interactive components. Framing native user messages, rounding the native prompt editor, changing unordered-list markers, and enhancing fenced code blocks require reload-safe runtime patches because Pi does not currently expose public renderer hooks for those presentation details. Markdown parsing, syntax highlighting, and terminal semantic zones remain handled by Pi.
+Tool rendering uses Pi's documented extension APIs. Active-tool state follows Pi's built-in execution transitions through its exported interactive components. Clean-mode thought details use the activity hierarchy's own disclosure state; full and compact modes retain Pi's built-in Thinking visibility control. Framing native user messages, rounding the native prompt editor, changing unordered-list markers, and enhancing fenced code blocks require reload-safe runtime patches because Pi does not currently expose public renderer hooks for those presentation details. Markdown enhancements are activated only while rendering user and assistant messages in the main transcript; Markdown created by extension overlays keeps Pi's native layout. Markdown parsing, syntax highlighting, and terminal semantic zones remain handled by Pi.
 
 No Pi source files are modified. Runtime patches are removed during session shutdown, but a future Pi release may require this extension to be updated.
 

package/README.zh-CN.md

@@ -6,11 +6,12 @@
 
 ## 功能特性
 
-- **可折叠的工具活动：** 不再让大量独立工具调用填满对话。工作进行时，受支持的工具会集中显示为一行 `Running(...)`；工作结束后，则变为低调的 `Done(...)`。点击分组可展开紧凑的子工具列表，点击任一子工具可查看完整详情，再次点击父级即可全部折叠。
+- **可折叠的活动时间线：** 不再让大量独立调用填满对话。思考、工具和普通 `info` 通知会进入同一条按真实时间排序的活动流；工作进行时显示为 `Running(...)`，结束后变为低调的 `Done(...)`。父级只统计工具调用和思考数量；展开后可查看所有有序成员，成员摘要在展开嵌套详情后仍然保留。思考与工具地位相同：没有调用任何工具的那一轮同样会有自己的 `Running(1 thought)` / `Done(1 thought)` 父行，思考作为其子级，内容不会被丢弃。
+- **临时 UI 状态：** 编辑器上方的一行只显示 Pi 直接产生的 UI 操作反馈，例如 Thinking 或工具输出可见性变化。新状态会替换旧状态，并在十秒后自动消失，不进入 transcript 或 session。
 - **按需查看有效信息：** 针对不同工具设计的摘要，会简洁呈现路径、命令、结果、diff、文件预览和实时 shell 输出，同时保留查看原始完整内容的能力。
 - **统一、精致的视觉体验：** 圆角用户消息与输入框、主题感知配色、层级清晰的 Markdown 标题、更清爽的列表，以及带语法高亮的圆角代码块，让整个 TUI 更协调。在 fullscreen 模式下，每个围栏代码块还带有符合原生体验的 `[Copy]` 控件。
 
-可折叠分组覆盖 Pi 内置的 `read`、`bash`、`edit`、`write`、`grep`、`find` 和 `ls` 工具。第三方工具保留自己的渲染方式，同时不会影响 Pi 原有的光标、输入法、自动补全、鼠标交互和工具执行行为。
+Pi 内置的 `read`、`bash`、`edit`、`write`、`grep`、`find` 和 `ls` 工具使用专门设计的紧凑视图；所有第三方工具会自动获得统一的紧凑行，单独展开时继续使用原生 renderer，但会移除与整体冲突的终端背景色。用户与 steer 消息、compaction 摘要、可见 assistant 正文、warning、error、aborted/length 响应，以及注册了专用 renderer 的 displayed custom message 都会形成硬分组边界。同时不会影响 Pi 原有的光标、输入法、自动补全、鼠标交互和工具执行行为。
 
 ## 安装
 
@@ -24,15 +25,23 @@ Pi 可能会提示内置工具被覆盖。这是正常现象：pi-pretty-tui 会
 
 ## 使用工具调用
 
-点击 `Running(...)` 或 `Done(...)` 行，可以保留父级并展开其下方的工具。点击单个子工具可切换完整视图，再次点击父级可折叠整个分组。任何时候都可以按 `Ctrl+O`，使用 Pi 的全局展开控制来显示或隐藏工具输出和思考内容。
+点击 `Running(...)` 或 `Done(...)` 行，可以保留父级并展开其下方的工具、已完成的 `● thought` 和扩展更新。点击单个工具或思考子项可在保留摘要的同时展开嵌套详情，再次点击父级可折叠整个分组。任何时候都可以按 `Ctrl+O`，使用 Pi 的全局展开控制来显示或隐藏全部工具输出和思考内容。工具名称会原样使用定义中的 `label`，没有 `label` 时回退到原始 `name`；pi-pretty-tui 不再重命名或转换大小写。
 
-## 渲染模式
+扩展调用 `ctx.ui.notify(message, "info")`（或省略 type）时，如果当前已有 thought/tool 活动组，通知会按真实时间顺序加入该组；如果没有现有工作，则独立显示，并且不会附着到未来的工具组。warning 和 error 保持独立，分别使用黄色 `⚠` 和红色 `✕`，并形成硬边界。工具失败继续归属于对应工具详情。上述扩展通知和错误都不会进入临时 UI 状态栏。
 
-扩展支持三种可持久化的渲染模式：`clean`（默认）、`compact` 和 `full`。运行 `/pretty-tui` 可交互选择，也可以直接使用 `/pretty-tui clean`、`/pretty-tui compact`、`/pretty-tui full` 和 `/pretty-tui status`。所选设置会保存到 `~/.pi/agent/pretty-tui.json`，或 `PI_CODING_AGENT_DIR` 指定目录中的对应位置。
+没有自有 renderer 的 displayed custom message 使用统一、accent 配色的 `◇` Markdown 显示：当前存在 thought/tool 工作时加入当前组，否则独立显示，并保留 session 持久化。注册了 renderer 的消息完全保留插件原生显示并形成硬边界。所有判断只依据 Pi 的通知 type 和 renderer 是否存在，不识别扩展名称、custom message 名称，也不根据文本内容推断语义。
+
+Pi 内部直接调用 `showStatus()` 产生的反馈属于临时 UI 状态：它只显示在编辑器上方，新状态替换旧状态，并由十秒 timer 自动清除；它不会进入 transcript 或活动时间线，reload 时也会清除。在 clean 模式下，`Ctrl+T` 不修改 Pi 持久化的 Thinking 设置，只显示一条简短提示；thought 详情仅在点击对应子项时展开，`Ctrl+O` 继续负责全局活动展开。在 full 和 compact 模式下，`Ctrl+T` 保留 Pi 的原生行为。
+
+## 设置与渲染模式
+
+运行 `/pretty-tui` 可打开扩展设置。`Enabled` 开关会持久化控制 pi-pretty-tui 是否安装渲染补丁和内置工具 renderer。修改后会自动调用 Pi 官方的 reload 流程，无需手动执行 `/reload`。也可以直接使用 `/pretty-tui enable` 和 `/pretty-tui disable`。禁用期间设置命令仍然可用，Pi 会恢复原生渲染。
+
+扩展支持三种可持久化的渲染模式：`clean`（默认）、`compact` 和 `full`。可交互选择，也可以直接使用 `/pretty-tui clean`、`/pretty-tui compact`、`/pretty-tui full` 和 `/pretty-tui status`。设置会保存到 `~/.pi/agent/pretty-tui.json`，或 `PI_CODING_AGENT_DIR` 指定目录中的对应位置。
 
 ## 复制代码块
 
-在 fullscreen TUI 模式下，Markdown 围栏代码块的顶部边框会显示可点击的 `[Copy]` 控件：
+在 fullscreen TUI 模式下，用户消息与助手回复中的 Markdown 围栏代码块会在顶部边框显示可点击的 `[Copy]` 控件：
 
 ```sh
 pi --tui-mode fullscreen
@@ -49,11 +58,11 @@ npm install
 npm test
 ```
 
-测试覆盖实时与历史恢复时的 steer/compaction 边界、并行工具完成归属、孤立 tool call、重复摘要防护，以及 fullscreen 代码块复制的点击区域。GitHub Actions 会在每次 push 和 pull request 时运行相同检查。
+测试覆盖实时与历史恢复的活动时间线、自动重试与终止状态、用户/steer/compaction/原生 renderer 边界、十秒 UI 状态替换、reload 与 shutdown 时的旧 timer 与状态清理、独立严重级别样式、内置与第三方工具、可展开思考、并行工具完成归属、孤立 tool call、重复摘要防护、原型补丁的完整恢复，以及 fullscreen 代码块复制的点击区域。GitHub Actions 会在每次 push 和 pull request 时运行相同检查。
 
 ## 兼容性说明
 
-工具渲染使用 Pi 的公开扩展 API。思考内容的可见性与活动工具状态，通过 Pi 导出的交互组件跟随其内置展开和执行状态变化。由于 Pi 目前没有为这些展示细节提供公开渲染钩子，原生用户消息框、原生输入编辑器圆角、无序列表标记和围栏代码块增强需要使用可安全重载的运行时补丁。Markdown 解析、语法高亮和终端语义区域仍由 Pi 处理。
+工具渲染使用 Pi 的公开扩展 API。活动工具状态通过 Pi 导出的交互组件跟随其内置执行状态变化；clean 模式的 thought 详情使用活动时间线自身的展开状态，full 和 compact 模式则保留 Pi 内置的 Thinking 可见性控制。由于 Pi 目前没有为这些展示细节提供公开渲染钩子，原生用户消息框、原生输入编辑器圆角、无序列表标记和围栏代码块增强需要使用可安全重载的运行时补丁。Markdown 增强仅在渲染主 transcript 中的用户消息和助手回复时启用；扩展 overlay 创建的 Markdown 保持 Pi 原生布局。Markdown 解析、语法高亮和终端语义区域仍由 Pi 处理。
 
 本扩展不会修改 Pi 源文件。运行时补丁会在会话关闭时移除，但未来的 Pi 版本可能需要本扩展同步适配。
 

package/extensions/activity-timeline.ts

@@ -0,0 +1,340 @@
+export type ActivityMemberKind = "tool" | "thinking" | "update";
+export type ActivitySeverity = "info" | "warning" | "error";
+
+export type ActivityMember = {
+  id: string;
+  kind: ActivityMemberKind;
+  toolCallId?: string;
+  toolName?: string;
+  messageKey?: string;
+  thinking?: string;
+  updateKey?: string;
+  updateTitle?: string;
+  updateContent?: string;
+  updateSeverity?: ActivitySeverity;
+  persistent?: boolean;
+};
+
+export type ActivityGroup = {
+  id: string;
+  members: ActivityMember[];
+  toolCallIds: string[];
+  thoughtCount: number;
+  hardBoundarySplit?: boolean;
+};
+
+const toolMemberId = (toolCallId: string) => `tool:${toolCallId}`;
+const thinkingMemberId = (messageKey: string) => `thinking:${messageKey}`;
+const updateMemberId = (updateKey: string) => `update:${updateKey}`;
+
+/**
+ * Transcript-first activity grouping. The timeline owns chronology and hard
+ * boundaries; renderers only project its groups into Pi components.
+ */
+export class ActivityTimeline {
+  private groupsById = new Map<string, ActivityGroup>();
+  private membersById = new Map<string, ActivityMember>();
+  private memberGroups = new Map<string, string>();
+  private toolMembers = new Map<string, string>();
+  private thinkingMembers = new Map<string, string>();
+  private updateMembers = new Map<string, string>();
+  private settledGroups = new Set<string>();
+  private currentGroupId?: string;
+  private sequence = 0;
+
+  clear(): void {
+    this.groupsById.clear();
+    this.membersById.clear();
+    this.memberGroups.clear();
+    this.toolMembers.clear();
+    this.thinkingMembers.clear();
+    this.updateMembers.clear();
+    this.settledGroups.clear();
+    this.currentGroupId = undefined;
+    this.sequence = 0;
+  }
+
+  /**
+   * Ends the current group. Because every hard transcript boundary routes here,
+   * a closed group can never receive further members, which makes this the
+   * completion signal for groups that have no durable tool summary.
+   */
+  boundary(settled = true): void {
+    if (settled && this.currentGroupId) this.settledGroups.add(this.currentGroupId);
+    this.currentGroupId = undefined;
+  }
+
+  isSettled(groupId: string): boolean {
+    return this.settledGroups.has(groupId);
+  }
+
+  private ensureCurrentGroup(): ActivityGroup {
+    if (this.currentGroupId) {
+      const current = this.groupsById.get(this.currentGroupId);
+      if (current) return current;
+    }
+    const id = `activity:${++this.sequence}`;
+    const group: ActivityGroup = {
+      id,
+      members: [],
+      toolCallIds: [],
+      thoughtCount: 0,
+    };
+    this.groupsById.set(id, group);
+    this.currentGroupId = id;
+    return group;
+  }
+
+  addTool(toolCallId: string, toolName: string): ActivityMember {
+    const existingId = this.toolMembers.get(toolCallId);
+    if (existingId) return this.member(existingId)!;
+    const member: ActivityMember = {
+      id: toolMemberId(toolCallId),
+      kind: "tool",
+      toolCallId,
+      toolName,
+    };
+    const group = this.ensureCurrentGroup();
+    group.members.push(member);
+    group.toolCallIds.push(toolCallId);
+    this.membersById.set(member.id, member);
+    this.memberGroups.set(member.id, group.id);
+    this.toolMembers.set(toolCallId, member.id);
+    return member;
+  }
+
+  addThinking(messageKey: string, thinking: string): ActivityMember | undefined {
+    const normalized = thinking.trim();
+    if (!normalized) return undefined;
+    const existingId = this.thinkingMembers.get(messageKey);
+    if (existingId) {
+      const existing = this.member(existingId);
+      if (existing) existing.thinking = normalized;
+      return existing;
+    }
+    const member: ActivityMember = {
+      id: thinkingMemberId(messageKey),
+      kind: "thinking",
+      messageKey,
+      thinking: normalized,
+    };
+    const group = this.ensureCurrentGroup();
+    group.members.push(member);
+    group.thoughtCount += 1;
+    this.membersById.set(member.id, member);
+    this.memberGroups.set(member.id, group.id);
+    this.thinkingMembers.set(messageKey, member.id);
+    return member;
+  }
+
+  addUpdate(
+    updateKey: string,
+    title: string,
+    content: string,
+    persistent: boolean,
+    severity: ActivitySeverity = "info",
+  ): ActivityMember | undefined {
+    if (!this.currentGroupId) return undefined;
+    return this.addUpdateToGroup(this.currentGroupId, updateKey, title, content, persistent, severity);
+  }
+
+  addPendingUpdate(
+    updateKey: string,
+    title: string,
+    content: string,
+    persistent: boolean,
+    severity: ActivitySeverity = "info",
+  ): ActivityMember {
+    const existingId = this.updateMembers.get(updateKey);
+    if (existingId) return this.member(existingId)!;
+    const group = this.ensureCurrentGroup();
+    return this.appendUpdate(group, updateKey, title, content, persistent, severity);
+  }
+
+  /**
+   * A group can receive update members only once it holds real work. This is
+   * the single definition of that condition: thinking counts even before any
+   * tool has run, because an activity group is created by the first thought.
+   */
+  hasWork(group: ActivityGroup | undefined): boolean {
+    return Boolean(group?.members.some(
+      (member) => member.kind === "tool" || member.kind === "thinking",
+    ));
+  }
+
+  addUpdateToGroup(
+    groupId: string,
+    updateKey: string,
+    title: string,
+    content: string,
+    persistent: boolean,
+    severity: ActivitySeverity = "info",
+  ): ActivityMember | undefined {
+    const existingId = this.updateMembers.get(updateKey);
+    if (existingId) return this.member(existingId);
+    const group = this.groupsById.get(groupId);
+    if (!this.hasWork(group)) return undefined;
+    return this.appendUpdate(group!, updateKey, title, content, persistent, severity);
+  }
+
+  private appendUpdate(
+    group: ActivityGroup,
+    updateKey: string,
+    title: string,
+    content: string,
+    persistent: boolean,
+    severity: ActivitySeverity = "info",
+  ): ActivityMember {
+    const member: ActivityMember = {
+      id: updateMemberId(updateKey),
+      kind: "update",
+      updateKey,
+      updateTitle: title.trim() || "Update",
+      updateContent: content.trim(),
+      updateSeverity: severity,
+      persistent,
+    };
+    group.members.push(member);
+    this.membersById.set(member.id, member);
+    this.memberGroups.set(member.id, group.id);
+    this.updateMembers.set(updateKey, member.id);
+    return member;
+  }
+
+  currentGroup(): ActivityGroup | undefined {
+    return this.currentGroupId ? this.groupsById.get(this.currentGroupId) : undefined;
+  }
+
+  groups(): ActivityGroup[] {
+    return [...this.groupsById.values()];
+  }
+
+  group(groupId: string): ActivityGroup | undefined {
+    return this.groupsById.get(groupId);
+  }
+
+  member(memberId: string): ActivityMember | undefined {
+    return this.membersById.get(memberId);
+  }
+
+  groupForMember(memberId: string): ActivityGroup | undefined {
+    const groupId = this.memberGroups.get(memberId);
+    return groupId ? this.groupsById.get(groupId) : undefined;
+  }
+
+  memberForTool(toolCallId: string): ActivityMember | undefined {
+    const memberId = this.toolMembers.get(toolCallId);
+    return memberId ? this.member(memberId) : undefined;
+  }
+
+  memberForThinking(messageKey: string): ActivityMember | undefined {
+    const memberId = this.thinkingMembers.get(messageKey);
+    return memberId ? this.member(memberId) : undefined;
+  }
+
+  memberForUpdate(updateKey: string): ActivityMember | undefined {
+    const memberId = this.updateMembers.get(updateKey);
+    return memberId ? this.member(memberId) : undefined;
+  }
+
+  /**
+   * Releases a claimed update and splits the group at that point, so a native
+   * custom renderer can take the message over without the remaining members
+   * being reordered around it.
+   */
+  removeUpdate(updateKey: string): boolean {
+    const memberId = this.updateMembers.get(updateKey);
+    if (!memberId) {
+      this.boundary();
+      return false;
+    }
+    const groupId = this.memberGroups.get(memberId);
+    const group = groupId ? this.groupsById.get(groupId) : undefined;
+    if (group) {
+      const index = group.members.findIndex((member) => member.id === memberId);
+      if (index >= 0) {
+        const following = group.members.slice(index + 1);
+        group.members = group.members.slice(0, index);
+        group.hardBoundarySplit = true;
+        group.toolCallIds = group.members
+          .filter((member) => member.kind === "tool" && member.toolCallId)
+          .map((member) => member.toolCallId!);
+        group.thoughtCount = group.members.filter((member) => member.kind === "thinking").length;
+
+        if (following.length > 0) {
+          const nextId = `activity:${++this.sequence}`;
+          const next: ActivityGroup = {
+            id: nextId,
+            members: following,
+            toolCallIds: following
+              .filter((member) => member.kind === "tool" && member.toolCallId)
+              .map((member) => member.toolCallId!),
+            thoughtCount: following.filter((member) => member.kind === "thinking").length,
+            hardBoundarySplit: true,
+          };
+          const ordered = new Map<string, ActivityGroup>();
+          for (const [id, existing] of this.groupsById) {
+            ordered.set(id, existing);
+            if (id === group.id) ordered.set(next.id, next);
+          }
+          this.groupsById = ordered;
+          for (const member of following) this.memberGroups.set(member.id, next.id);
+          if (this.currentGroupId === group.id) this.currentGroupId = next.id;
+        } else if (this.currentGroupId === group.id) {
+          this.currentGroupId = undefined;
+        }
+      }
+      if (group.members.length === 0) {
+        this.groupsById.delete(group.id);
+        if (this.currentGroupId === group.id) this.currentGroupId = undefined;
+      }
+    }
+    this.updateMembers.delete(updateKey);
+    this.memberGroups.delete(memberId);
+    this.membersById.delete(memberId);
+    return true;
+  }
+
+  groupForTool(toolCallId: string): ActivityGroup | undefined {
+    const member = this.memberForTool(toolCallId);
+    return member ? this.groupForMember(member.id) : undefined;
+  }
+
+  groupForThinking(messageKey: string): ActivityGroup | undefined {
+    const member = this.memberForThinking(messageKey);
+    return member ? this.groupForMember(member.id) : undefined;
+  }
+
+  groupForUpdate(updateKey: string): ActivityGroup | undefined {
+    const member = this.memberForUpdate(updateKey);
+    return member ? this.groupForMember(member.id) : undefined;
+  }
+}
+
+export const assistantMessageKey = (message: any): string => {
+  const timestamp = message?.timestamp;
+  if (typeof timestamp === "number" || typeof timestamp === "string") return String(timestamp);
+  const firstToolCall = Array.isArray(message?.content)
+    ? message.content.find((item: any) => item?.type === "toolCall" && item.id)?.id
+    : undefined;
+  return firstToolCall ? `tool-message:${firstToolCall}` : `message:${JSON.stringify(message?.content ?? "")}`;
+};
+
+export const thinkingText = (message: any): string => {
+  if (!Array.isArray(message?.content)) return "";
+  return message.content
+    .filter((item: any) => item?.type === "thinking" && typeof item.thinking === "string")
+    .map((item: any) => item.thinking.trim())
+    .filter(Boolean)
+    .join("\n\n");
+};
+
+export const visibleAssistantText = (message: any): boolean =>
+  typeof message?.content === "string"
+    ? message.content.trim().length > 0
+    : Array.isArray(message?.content) && message.content.some(
+      (item: any) => item?.type === "text" && typeof item.text === "string" && item.text.trim().length > 0,
+    );
+
+export const assistantTerminalState = (message: any): boolean =>
+  message?.role === "assistant" && ["error", "aborted", "length"].includes(message?.stopReason);