comate-cli 0.7.0a7__tar.gz → 0.7.0a9__tar.gz

comate_cli-0.7.0a9/AGENTS.md

@@ -0,0 +1,115 @@
+## global rule
+1. 涉及到 Prompt_toolkit 这个TUI框架, 你必须使用 context7 mcp里面的  query-docs和resolve-library-id 功能来查询相关文档, 以确保你对这个框架的理解是正确的. this is MUST
+2. 总是使用中文编写详细的git commit message
+
+## 12条黄金规则
+
+这些规则适用于本项目中的每一个任务，除非被明确覆盖。核心原则：非简单任务宁可谨慎，不要图快。简单任务可以灵活处理。
+
+1. 动手之前先动脑
+把你的假设说出来。不确定就问，别猜。遇到模糊需求时，列出多种可能的理解。如果有更简单的方案，要敢于提出来。搞不清楚的时候就停下来，把不清楚的点明确说出来。
+
+2. 简单至上
+写能解决问题的最少代码，不写投机性代码。不加需求以外的功能。一次性代码不搞抽象封装。自测标准：一个资深工程师看了会不会觉得过度设计？如果会，就简化。
+
+3. 精准修改，不多动
+只改必须改的地方。只清理自己弄乱的部分。不要顺手"优化"旁边的代码、注释或格式。没坏的东西不要重构。风格跟已有代码保持一致。
+
+4. 以目标驱动执行
+先定义成功标准，然后循环迭代直到验证通过。不要机械地按步骤走，而是盯着目标不断调整。有了清晰的成功标准，你才能自主地持续迭代。
+
+5. 模型只用于需要判断力的场景
+适合用 AI 做的事：分类、起草、总结、信息提取。不该用 AI 做的事：路由分发、重试逻辑、确定性转换。如果写代码就能搞定，就用代码搞定。
+
+6. 核实优先于推断（冰山法则）
+你在上下文中看到的信息只是冰山一角，不能代替真实验证。
+判断标准不是"我有没有说出猜测的话"，而是"我这个结论背后有没有本轮刚验证过的事实支撑"——只要要陈述文件/函数/配置内容或修改代码，却没有刚读过、刚确认过，就是在猜，必须先验证再继续。
+
+7. 遇到冲突要选边，不要和稀泥
+两种模式互相矛盾时，选一个（优先选更新的或经过更多验证的），说明理由，把另一个标记为待清理。不要把两种冲突的模式混在一起用。
+
+8. 先读再写
+写新代码之前，先读清楚现有的导出接口、直接调用方、公共工具函数。"看起来互不相关"这种判断很危险。如果不理解代码为什么这样写，先问。
+
+9.  测试要验证意图，不只是行为
+测试必须体现某个行为**为什么**重要，而不仅仅是**做了什么**。如果业务逻辑变了，测试却不会挂，那这个测试就是有问题的。
+
+10.  每完成一个重要步骤就做检查点
+总结一下：做了什么、验证了什么、还剩什么。不要在一个自己都说不清楚的状态上继续推进。如果失去了方向感，停下来，重新陈述当前状态。
+
+11.  跟着项目的既有约定走，哪怕你不认同
+在项目内部，一致性 > 个人偏好。如果你真觉得某个约定有害，把问题提出来讨论，但不要悄悄另搞一套。
+
+12. 有问题就大声说
+如果有东西被悄悄跳过了，不能说"已完成"。如果有测试被跳过了，不能说"测试全过"。默认立场是把不确定性暴露出来，而不是藏起来。
+
+
+## python coding rule
+1. 代码必须使用 logging 模块进行日志记录，禁止使用 print 语句
+2. 运行 python必须使用 uv run python 脚本名.py 的方式运行
+3. 安装pip包必须使用 uv add 包名 的方式安装
+
+## Context 重建铁律
+comate_agent_sdk 的上下文重建规则是高优先级架构约束。涉及 static header / session_state / conversation 三层分离、header_snapshot 的 first-snapshot-wins 语义、resume / fork / compact / clear_history 各自的不变量，以及最低测试护栏清单。
+任何改动涉及 chat_session.py、context/ir.py、context/compaction.py、agent/history.py、agent/init.py、agent/setup.py 时 MUST 先阅读完整规则。
+→ ./rules/context-rebuild.md
+
+## Token 账本语义铁律
+
+comate_agent_sdk 的 token 相关概念分属不同账本，后续改动 MUST 先阅读完整规则，禁止为了修某个阈值或展示问题把不同账本混算。
+→ ./rules/token-accounting.md
+
+## TUI 编程铁律
+不做 History TUI，历史只写 scrollback。layout 只允许底部交互带。颜色策略以 shell 背景为准。包含 Team 事件显示铁律和 Pre-flight TUI 铁律。
+涉及 prompt_toolkit layout、team 事件渲染、独立 Application 弹窗时 MUST 先阅读完整规则。
+→ ./rules/tui.md
+
+## 代码放置规则
+
+当需要为某个模块添加新功能时，先判断：这个功能是该模块的 **核心职责** 还是 **业务扩展**？
+
+- **核心职责**：直接操作该模块自身管理的数据结构 → 可以加方法
+- **业务扩展**：借用该模块的 API 完成上层业务目标 → 在调用方实现，禁止侵入
+
+判断标准：如果删掉这个方法，该模块的核心抽象（数据结构 + 主流程）是否仍然完整？
+如果仍然完整，说明这个方法不属于这里。
+
+实践要求：
+1. 新增方法前，说明它属于核心职责还是业务扩展
+2. 如果是业务扩展，必须放在调用方或独立 service 中，通过公共 API 操作
+3. 单个模块超过 500 行时，主动审视是否有职责泄漏
+
+## Prompt 工程规则
+
+涉及 SDK 内置 prompt / 提示词时，后续 agent MUST 默认遵循以下约定，禁止重新回到“局部硬编码 + 局部替换”的分散实现。
+
+- SDK 自带 prompt 资源 MUST 放在 `comate_agent_sdk/prompts/` 下，按领域分目录，例如 `agent/`、`subagent/`。
+- 新增 prompt 时，优先判断它是 **SDK 静态资源** 还是 **调用方临时拼接文本**：
+  - SDK 静态资源：放入 `comate_agent_sdk/prompts/`，通过统一 loader 读取。
+  - 调用方临时拼接文本：保留在调用方，禁止为了“统一”硬塞进不相关模块。
+- MUST 使用两阶段接口：
+  - `load_prompt()` 只负责读取包内 markdown 资源。
+  - `render_prompt()` 只负责变量渲染。
+- 新 prompt 的变量语法 MUST 统一使用 `{{VAR_NAME}}`，不要新增 `{var}`、`%s`、手写 `replace()` 等新风格。
+
+## System Tool 描述工程规则
+
+涉及 SDK 内置 system tool 的 schema description / system prompt usage_rules / 默认上限值时，
+后续 agent MUST 默认遵循以下约定。
+
+→ ./rules/system-tool-prompt-conventions.md
+
+## Tool Envelope 与 Typed Schema 铁律
+
+comate_agent_sdk 内置 system tool 的"信封 (`ok/err` 6-key envelope) + typed OutputSchema + `ToolMessage.raw_envelope` 三轨分离"是 typed `ToolResultEvent.output`、SDK 投影、resume 持久化、reminder 引擎共同依赖的事实契约。envelope 一旦被静默改形 / 截断 / 污染框架字段，会让 typed 事件、投影、reminder、jsonl resume **同时静默失效**。
+
+涉及以下任一项 MUST 先阅读完整规则，禁止仅"局部 patch"：
+
+- `comate_agent_sdk/system_tools/tool_result.py`、`tool_schemas/`（含 `_registry.py` / `_projection.py` / `_base.py` / 各 `<tool>.py`）、`system_tools/tools|task|team/` 下 system tool 的返回结构。
+- `agent/tool_exec.py` 中 `_build_tool_result_message()` / `_extract_tool_envelope()`、`llm/messages.py` 中 `ToolMessage` 的 `content` / `raw_envelope` / `execution_meta` 字段、`mcp/manager.py` 中 `McpToolResult`。
+- `agent/runner_engine/execution/tool_execution.py` 的 `_resolve_tool_output()`、`runner_engine/projection/tool_result_projection.py`、`agent/events.py` 中 `ToolResultEvent.output`、`context/reminder_engine.py`、`subagent/team_session.py`、`chat_session.py` resume 路径。
+- size guard / truncation / artifact spill 与 envelope 关系的任何 plan。
+
+核心铁律一句话：**system tool 必须 `ok()/err()` envelope；envelope 形状不可破坏性变更；envelope 是 typed schema 唯一原料；envelope 只装业务字段，框架元数据走 `execution_meta`；envelope 严禁 slim / 入 prompt / 被 monkey-patch 注册；MCP 用 `McpToolResult.raw_result`、不混 `raw_envelope`；用户 `@tool` 永远是 `CustomToolOutput`。**
+
+→ ./rules/tool-envelope.md

{comate_cli-0.7.0a7 → comate_cli-0.7.0a9}/CHANGELOG.md

@@ -13,6 +13,10 @@
 
 ### Added
 
+- 新增 `/clear` slash command：清空当前 leader session 的 conversation，
+  保留 session_id、team membership、inbox 与 TaskStore。成功后会清屏、
+  重打 logo、重置 TUI transcript view，并刷新 status bar；busy 或
+  compacting 状态会拒绝执行。
 - `_ShutdownNoiseGuard` 扩展为四合一接管器：SIGINT、`sys.unraisablehook`、
   `sys.excepthook`、`warnings.showwarning`。捕获到的噪音统一路由到独立的
   `comate.noise` logger（`propagate=False`），写入 `~/.comate/logs/agent.log`。

{comate_cli-0.7.0a7 → comate_cli-0.7.0a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.0a7
+Version: 0.7.0a9
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk

{comate_cli-0.7.0a7 → comate_cli-0.7.0a9}/comate_cli/terminal_agent/animations.py

@@ -9,7 +9,7 @@ from enum import Enum
 from rich.console import RenderableType
 from rich.text import Text
 
-from comate_agent_sdk.agent.events import StopEvent, TextEvent, ToolCallEvent, ToolResultEvent, UserQuestionEvent
+from comate_agent_sdk.agent.events import StopEvent, ToolCallEvent, ToolResultEvent, UserQuestionEvent
 
 from comate_cli.terminal_agent.figures import (
     BREATH_DOT_GLYPHS as _FIGURES_BREATH_DOT_GLYPHS,
@@ -238,6 +238,27 @@ BREATH_DOT_COLORS: tuple[str, ...] = (
 )
 BREATH_DOT_GLYPHS: tuple[str, ...] = _FIGURES_BREATH_DOT_GLYPHS
 
+LOADING_SPINNER_FRAMES: tuple[str, ...] = (
+    "⠋",
+    "⠙",
+    "⠹",
+    "⠸",
+    "⠼",
+    "⠴",
+    "⠦",
+    "⠧",
+    "⠇",
+    "⠏",
+)
+
+HIDDEN_THINKING_BADGES: tuple[str, ...] = (
+    "ultra thinking",
+    "deep reasoning",
+    "thinking deeper",
+    "extended thinking",
+    "working through it",
+)
+
 
 def breathing_dot_color(frame: int) -> str:
     """Return the breathing dot color for a given animation frame."""
@@ -252,6 +273,11 @@ def breathing_dot_glyph(now_monotonic: float | None = None) -> str:
     return BREATH_DOT_GLYPHS[phase]
 
 
+def loading_spinner_glyph(frame: int) -> str:
+    """Return the compact spinner glyph for the main loading line."""
+    return LOADING_SPINNER_FRAMES[frame % len(LOADING_SPINNER_FRAMES)]
+
+
 def _lerp_rgb(
     start_rgb: tuple[int, int, int],
     end_rgb: tuple[int, int, int],
@@ -385,11 +411,9 @@ class SubmissionAnimator:
             return Text("")
 
         phrase = self._status_hint if self._status_hint else (self._shuffled[self._phrase_idx] + ELLIPSIS)
-        dot_color = breathing_dot_color(self._frame)
-        now_monotonic = time.monotonic()
         dot = Text(
-            f"{breathing_dot_glyph(now_monotonic)} ",
-            style=f"bold {dot_color}",
+            f"{loading_spinner_glyph(self._frame)} ",
+            style="bold #9CA3AF",
         )
         sweep = _cyan_sweep_text(phrase, frame=self._frame)
         return Text.assemble(dot, sweep)

{comate_cli-0.7.0a7 → comate_cli-0.7.0a9}/comate_cli/terminal_agent/event_renderer.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import random
 import re
 import threading
 import time
@@ -37,6 +38,7 @@ from comate_agent_sdk.agent.events import (
 from rich.console import RenderableType
 from rich.text import Text
 
+from comate_cli.terminal_agent.animations import HIDDEN_THINKING_BADGES
 from comate_cli.terminal_agent.figures import (
     BOTTOM_LEFT_CROP,
     BULLET_OPERATOR,
@@ -59,6 +61,11 @@ from comate_cli.terminal_agent.tool_result_store import (
     ToolResultRegistry,
 )
 from comate_cli.terminal_agent.tool_view import summarize_tool_args, resolve_display_tool_name, should_show_tool_in_scrollback
+from comate_cli.terminal_agent.tool_fold import (
+    ActiveToolFold,
+    ToolFoldSnapshot,
+    is_foldable_tool,
+)
 from comate_cli.terminal_agent.env_utils import read_env_int
 from comate_cli.terminal_agent.custom_slash_commands import FILE_REF_PATTERN
 logger = logging.getLogger(__name__)
@@ -258,6 +265,7 @@ class EventRenderer:
         self._history: list[HistoryEntry] = []
         self._running_tools: dict[str, _RunningTool] = {}
         self._tool_call_args: dict[str, dict[str, Any]] = {}
+        self._active_tool_fold = ActiveToolFold()
         self._tool_results = tool_results
         self._fallback_tool_result_sequence = 0
         self._assistant_buffer = ""
@@ -286,6 +294,7 @@ class EventRenderer:
         self._show_thinking_cb: Callable[[], bool] = lambda: True
         self._turn_received_text_delta: bool = False
         self._turn_received_thinking_delta: bool = False
+        self._hidden_thinking_badge_text: str = ""
         self._text_delta_started: bool = False
         self._active_text_message_id: str | None = None
         # ━━━━━ spec §4.1 新管道状态字段（Phase 1.2 引入，Phase 4-6 接入） ━━━━━
@@ -358,6 +367,21 @@ class EventRenderer:
         if entry.entry_type == "tool_result":
             self.flush_pending_logs()
 
+    def _commit_active_tool_fold(self) -> None:
+        snapshot = self._active_tool_fold.snapshot(active=False)
+        if snapshot is None:
+            return
+        self._append_history_entry(
+            HistoryEntry(
+                entry_type="tool_fold",
+                text=snapshot.summary,
+                severity="error" if snapshot.any_error else "info",
+                subtitle=snapshot.error_summary or snapshot.latest_hint,
+                tool_call_ids=snapshot.tool_call_ids,
+            )
+        )
+        self._active_tool_fold.clear()
+
     # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     # spec §6 流式新管道方法集（Phase 1-6 新增；Phase 7 接入 handle_event）
     # 容器检测原语（spec §6.3）
@@ -452,6 +476,10 @@ class EventRenderer:
         """
         if not delta:
             return
+        if self._show_thinking_cb():
+            self._hidden_thinking_badge_text = ""
+        elif not self._hidden_thinking_badge_text:
+            self._hidden_thinking_badge_text = random.choice(HIDDEN_THINKING_BADGES)
         self._thinking_batch += delta
         while "\n" in self._thinking_batch:
             line, self._thinking_batch = self._thinking_batch.split("\n", 1)
@@ -543,6 +571,7 @@ class EventRenderer:
         """
         if not delta:
             return
+        self._hidden_thinking_badge_text = ""
         if self._thinking_batch:
             self._flush_thinking_batch()
         self._text_pending += delta
@@ -583,6 +612,7 @@ class EventRenderer:
             self._flush_thinking_batch()
         # ⑤ aux
         self._loading_aux_text = ""
+        self._hidden_thinking_badge_text = ""
 
     def _drop_all_pending(self) -> None:
         """spec §6.4：interrupt_turn 调用。
@@ -593,6 +623,7 @@ class EventRenderer:
         self._container = None
         self._thinking_batch = ""
         self._loading_aux_text = ""
+        self._hidden_thinking_badge_text = ""
         self._text_delta_started = False
         self._active_text_message_id = None
 
@@ -636,6 +667,7 @@ class EventRenderer:
         self._container = None
         self._thinking_batch = ""
         self._loading_aux_text = ""
+        self._hidden_thinking_badge_text = ""
         self._rebuild_loading_line()
 
     def seed_user_message(
@@ -649,6 +681,7 @@ class EventRenderer:
         if not normalized:
             return
         self._flush_assistant_segment()
+        self._commit_active_tool_fold()
         if display_header and display_subtitle:
             # AskUserQuestion 答复入 scrollback：用 tool_result 样式渲染头行（●），
             # 答案明细作为 ⎿ subtitle 紧贴其下；行间不插入用户 prefix。
@@ -698,6 +731,7 @@ class EventRenderer:
         # spec §6.4：turn 结束 force flush 所有 pending（held / container /
         # text_pending / thinking）保证 scrollback 看到完整内容
         self._force_flush_all()
+        self._commit_active_tool_fold()
         self._flush_assistant_segment()
         self.flush_pending_logs()
         self._pending_tool_starts.clear()
@@ -720,6 +754,7 @@ class EventRenderer:
             )
         self._running_tools.clear()
         self._flush_assistant_segment()
+        self._commit_active_tool_fold()
         self._pending_tool_starts.clear()
         # spec §6.4：用户中断 → 5 个新字段全部丢弃不入队
         self._drop_all_pending()
@@ -728,12 +763,16 @@ class EventRenderer:
     def history_entries(self) -> list[HistoryEntry]:
         return list(self._history)
 
+    def active_tool_fold_snapshot(self) -> ToolFoldSnapshot | None:
+        return self._active_tool_fold.snapshot(active=True)
+
     def reset_history_view(self) -> None:
         """重置 history 视图状态（用于会话切换后的重新加载）。"""
         self._history = []
         self._recent_team_event_keys.clear()
         self._running_tools.clear()
         self._tool_call_args.clear()
+        self._active_tool_fold.clear()
         self._assistant_buffer = ""
         self._pending_tool_starts.clear()
         self._turn_received_text_delta = False
@@ -747,6 +786,7 @@ class EventRenderer:
         self._thinking_batch = ""
         self._loading_aux_text = ""
         self._loading_state = LoadingState.idle()
+        self._hidden_thinking_badge_text = ""
         self._current_tasks = []
         self._current_task_title = None
         self._task_started_at_monotonic = None
@@ -802,6 +842,10 @@ class EventRenderer:
         拼接到 spinner phrase。无容器时返回 ""。"""
         return self._loading_aux_text
 
+    def hidden_thinking_badge_text(self) -> str:
+        """Return the loading-line badge shown while hidden thinking streams."""
+        return self._hidden_thinking_badge_text
+
     def append_subtitle(
         self,
         text: str,
@@ -1182,11 +1226,6 @@ class EventRenderer:
         if state.is_task:
             subagent_name = state.subagent_name or "Agent"
             description = state.subagent_description or state.title
-            if description and description != subagent_name:
-                task_title = f"{subagent_name}({description})"
-            else:
-                task_title = subagent_name
-
             model_name = ""
             if metadata and isinstance(metadata, dict):
                 model_name = metadata.get("model_name", "")
@@ -1343,6 +1382,7 @@ class EventRenderer:
                 pass
             case TextDeltaEvent(delta=delta, message_id=message_id):
                 if delta:
+                    self._commit_active_tool_fold()
                     normalized_message_id = str(message_id or "").strip()
                     if normalized_message_id and normalized_message_id != self._active_text_message_id:
                         self._active_text_message_id = normalized_message_id
@@ -1382,40 +1422,50 @@ class EventRenderer:
                 attempted=attempted,
                 compacted=compacted,
                 reason=reason,
-                tokens_before=tokens_before,
+                tokens_before=_,
                 tokens_after=tokens_after,
             ):
                 self.clear_auto_compacting()
                 pct = int(tokens / threshold * 100) if threshold > 0 else 0
+                # precheck 的 tokens 是 estimate_precheck() 推算值；
+                # check 的 tokens 是上一次 API 返回的真实 context_usage。
+                trigger_label = "est." if trigger == "precheck" else "usage"
                 if compacted:
+                    reduction_pct = (
+                        max(0, int(((tokens - tokens_after) / tokens) * 100))
+                        if tokens > 0
+                        else 0
+                    )
                     self.append_system_message(
                         (
-                            f"Context compaction completed ({trigger}): "
-                            f"{tokens_before:,} {INJECTED_ARROW} {tokens_after:,} tokens "
-                            f"(check {tokens:,}/{threshold:,}, {pct}%)"
+                            f"Auto-compact done ({trigger}): "
+                            f"{trigger_label} {tokens:,} / threshold {threshold:,} ({pct}%)\n"
+                            f"  {INJECTED_ARROW} context reduced to ~{tokens_after:,} tokens "
+                            f"(-{reduction_pct}%)"
                         ),
                         severity="info",
                     )
                 elif attempted:
                     is_recoverable_deferred = str(reason).startswith("partial_compact_no_op:")
                     label = (
-                        "Context compaction deferred"
+                        "Auto-compact deferred"
                         if is_recoverable_deferred
-                        else "Context compaction attempt failed"
+                        else "Auto-compact attempt failed"
                     )
                     self.append_system_message(
                         (
                             f"{label} ({trigger}): "
-                            f"kept {tokens_after:,} tokens "
-                            f"(check {tokens:,}/{threshold:,}, {pct}%, reason={reason})"
+                            f"{trigger_label} {tokens:,} / threshold {threshold:,} ({pct}%), "
+                            f"reason={reason}"
                         ),
                         severity="warning",
                     )
                 else:
                     self.append_system_message(
                         (
-                            f"Context compaction skipped ({trigger}): "
-                            f"{tokens:,}/{threshold:,} tokens ({pct}%), reason={reason}"
+                            f"Auto-compact skipped ({trigger}): "
+                            f"{trigger_label} {tokens:,} / threshold {threshold:,} ({pct}%), "
+                            f"reason={reason}"
                         ),
                         severity="warning",
                     )
@@ -1423,12 +1473,46 @@ class EventRenderer:
                 args_dict = arguments if isinstance(arguments, dict) else {"_raw": str(arguments)}
                 # Store args for ToolResult phase lookup.
                 self._tool_call_args[tool_call_id] = args_dict
+                if is_foldable_tool(tool_name):
+                    self._active_tool_fold.add_call(
+                        tool_call_id=tool_call_id,
+                        tool_name=tool_name,
+                        args=args_dict,
+                        started_at_monotonic=time.monotonic(),
+                    )
+                    self._rebuild_loading_line()
+                    return (False, None)
+                self._commit_active_tool_fold()
                 if not should_show_tool_in_scrollback(tool_name, args_dict):
                     self._rebuild_loading_line()
                     return (False, None)
                 self._append_tool_call(tool_name, args_dict, tool_call_id)
             case ToolResultEvent(tool=tool_name, result=result, tool_call_id=tool_call_id, is_error=is_error, metadata=metadata, output=output):
                 stored_args = self._tool_call_args.pop(tool_call_id, {})
+                if self._active_tool_fold.has_call(tool_call_id):
+                    display_name = resolve_display_tool_name(tool_name, stored_args)
+                    rec = self._make_tool_result_record(
+                        tool_call_id=tool_call_id,
+                        tool_name=tool_name,
+                        display_name=display_name,
+                        started_at_monotonic=time.monotonic(),
+                        args=stored_args,
+                        is_error=is_error,
+                        result=result,
+                        metadata=metadata,
+                        output=output,
+                    )
+                    error_summary = None
+                    if is_error:
+                        error_summary = str(result).strip().splitlines()[0] if str(result).strip() else None
+                    self._active_tool_fold.mark_result(
+                        tool_call_id,
+                        is_error=is_error,
+                        result_record_sequence=rec.sequence,
+                        error_summary=error_summary,
+                    )
+                    self._rebuild_loading_line()
+                    return (False, None)
                 if not should_show_tool_in_scrollback(tool_name, stored_args, is_result=True, is_error=is_error):
                     self._running_tools.pop(tool_call_id, None)
                     self._rebuild_loading_line()
@@ -1532,6 +1616,7 @@ class EventRenderer:
                 if self._turn_received_text_delta:
                     pass
                 elif text:
+                    self._commit_active_tool_fold()
                     self._append_assistant_text(text)
             case StepCompleteEvent(step_id=step_id, status=_, duration_ms=_):
                 # Cancellation/error paths may emit StepCompleteEvent without ToolResultEvent.
@@ -1539,9 +1624,11 @@ class EventRenderer:
                 self._running_tools.pop(step_id, None)
             case StopEvent(reason=reason):
                 self._flush_assistant_segment()
+                self._commit_active_tool_fold()
                 self._pending_tool_starts.clear()
                 # Safety net: if any running tool rows remain, stop event means this turn is ending.
                 self._running_tools.clear()
+                self._hidden_thinking_badge_text = ""
                 self._rebuild_loading_line()
                 if reason == "waiting_for_input":
                     return (True, None)

{comate_cli-0.7.0a7 → comate_cli-0.7.0a9}/comate_cli/terminal_agent/history_printer.py

@@ -107,20 +107,40 @@ def _entry_content(
     entry: HistoryEntry,
     *,
     terminal_width: int,
-    render_markdown_to_plain: Callable[..., str],
-) -> str:
+    render_markdown_to_plain: Callable[..., str | Text],
+) -> str | Text:
     if entry.entry_type != "assistant":
         return str(entry.text)
     width = max(terminal_width - 6, 40)
     return render_markdown_to_plain(str(entry.text), width=width)
 
 
+def _render_prefixed_rich_text(
+    content: Text,
+    *,
+    prefix: str,
+    in_run_continuation: bool,
+) -> Text:
+    content_lines = content.split("\n") or [Text("")]
+    line_text = Text()
+    if in_run_continuation:
+        line_text.append("  ", style="bold")
+    else:
+        line_text.append(f"{prefix} ", style="bold")
+    line_text.append_text(content_lines[0])
+    for line in content_lines[1:]:
+        line_text.append("\n")
+        line_text.append("  ")
+        line_text.append_text(line)
+    return line_text
+
+
 def render_history_group(
     console: Console,
     entries: list[HistoryEntry],
     *,
     terminal_width: int,
-    render_markdown_to_plain: Callable[..., str],
+    render_markdown_to_plain: Callable[..., str | Text],
     prev_was_assistant: bool = False,
     prev_was_thinking: bool = False,
     assume_run_continues_at_tail: bool = False,
@@ -240,6 +260,33 @@ def render_history_group(
             subtitle_chain_active = True
             continue
 
+        if entry.entry_type == "tool_fold":
+            # 折叠组摘要：参考 thinking 的视觉处理（2 空格缩进 + dim 文案），
+            # 不带前缀圆点，行末追加 "(ctrl+o to expand)" 提示 Ctrl+O 展开。
+            is_error = entry.severity == "error"
+            content = str(entry.text).strip()
+            content_lines = [line for line in content.splitlines() if line.strip()] or [content]
+            suffix = " (ctrl+o to expand)" if entry.tool_call_ids else ""
+            text_style = "dim #FF6B6B" if is_error else "dim"
+
+            line_text = Text()
+            line_text.append("  ", style=text_style)
+            line_text.append(content_lines[0], style=text_style)
+            if suffix and len(content_lines) == 1:
+                line_text.append(suffix, style=text_style)
+            for idx_line, line in enumerate(content_lines[1:], start=1):
+                line_text.append("\n")
+                line_text.append("  ", style=text_style)
+                line_text.append(line, style=text_style)
+                if suffix and idx_line == len(content_lines) - 1:
+                    line_text.append(suffix, style=text_style)
+
+            renderables.append(line_text)
+            renderables.append(Text(""))
+            prev_was_assistant = False
+            subtitle_chain_active = False
+            continue
+
         if entry.entry_type == "tool_result":
             prefix_char = BLACK_CIRCLE
             prefix_style = "bold red" if entry.severity == "error" else "bold green"
@@ -253,10 +300,20 @@ def render_history_group(
                 first_line.append(f"{prefix_char} ", style=prefix_style)
                 first_line.append_text(text_lines[0] if text_lines else Text())
                 renderables.append(first_line)
+
+                has_body = len(text_lines) > 1
+                # For multi-line Rich Text bodies (Edit/Write inline diff),
+                # subtitle ("Added X, removed Y") goes between signature and
+                # body so the reader sees the summary before the diff. For
+                # single-line text (bash/grep/read previews), subtitle stays
+                # after the signature line as before.
+                if has_body and entry.subtitle:
+                    renderables.append(_render_subtitle_line(entry.subtitle, error=is_error))
                 for line in text_lines[1:]:
                     renderables.append(line)
-                if entry.subtitle:
+                if not has_body and entry.subtitle:
                     renderables.append(_render_subtitle_line(entry.subtitle, error=is_error))
+
                 renderables.append(Text(""))
                 prev_was_assistant = False
                 subtitle_chain_active = bool(entry.subtitle)
@@ -297,10 +354,10 @@ def render_history_group(
                 style = "bold #FF6B6B" if entry.severity == "error" else "#E8B830"
                 content_lines = content.splitlines() or [""]
                 line_text = Text()
-                line_text.append(content_lines[0], style=style)
+                line_text.append(f"  {content_lines[0]}", style=style)
                 for line in content_lines[1:]:
                     line_text.append("\n")
-                    line_text.append(line, style=style)
+                    line_text.append(f"  {line}", style=style)
                 renderables.append(line_text)
 
             subtitle_chain_active = False
@@ -324,16 +381,25 @@ def render_history_group(
                 terminal_width=terminal_width,
                 render_markdown_to_plain=render_markdown_to_plain,
             )
-            content_lines = content.splitlines() or [""]
-            if in_run_continuation:
-                first_line = f"  {content_lines[0]}"
+            if isinstance(content, Text):
+                renderables.append(
+                    _render_prefixed_rich_text(
+                        content,
+                        prefix=_entry_prefix(entry),
+                        in_run_continuation=in_run_continuation,
+                    )
+                )
             else:
-                prefix = _entry_prefix(entry)
-                first_line = f"{prefix} {content_lines[0]}"
-            lines = [first_line]
-            for line in content_lines[1:]:
-                lines.append(f"  {line}")
-            renderables.append("\n".join(lines))
+                content_lines = content.splitlines() or [""]
+                if in_run_continuation:
+                    first_line = f"  {content_lines[0]}"
+                else:
+                    prefix = _entry_prefix(entry)
+                    first_line = f"{prefix} {content_lines[0]}"
+                lines = [first_line]
+                for line in content_lines[1:]:
+                    lines.append(f"  {line}")
+                renderables.append("\n".join(lines))
 
         # 在 assistant run 内部不插入空行；只有 run 末尾才与下一段拉开。
         # assume_run_continues_at_tail=True 时（drain 在 streaming 中），把 batch
@@ -357,8 +423,11 @@ def render_history_group(
 
 
 async def print_history_group_async(console: Console, group: Group) -> None:
-    console.print(group, soft_wrap=True)
+    # highlight=False：Rich 默认 ReprHighlighter 会把 "/cmd" 误识别为 path/filename
+    # 并染成 magenta/bright-magenta（即"粉红色 slash 命令名"）。所有 entry 在
+    # render_history_group 内已自带 explicit Text 样式，不需要再做自动高亮。
+    console.print(group, soft_wrap=True, highlight=False)
 
 
 def print_history_group_sync(console: Console, group: Group) -> None:
-    console.print(group, soft_wrap=True)
+    console.print(group, soft_wrap=True, highlight=False)