comate-cli 0.2.4__tar.gz → 0.2.6__tar.gz

{comate_cli-0.2.4 → comate_cli-0.2.6}/.gitignore

@@ -5,6 +5,7 @@ __pycache__/
 .agent
 .agents
 set_env.sh
+.worktrees/
 # C extensions
 *.so
 

{comate_cli-0.2.4 → comate_cli-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.2.4
+Version: 0.2.6
 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.2.4 → comate_cli-0.2.6}/comate_cli/main.py

@@ -6,7 +6,10 @@ import logging
 import signal
 import subprocess
 import sys
-import termios
+try:
+    import termios
+except ImportError:
+    termios = None  # Windows 不支持
 import threading
 
 logger = logging.getLogger(__name__)
@@ -24,6 +27,8 @@ class _TerminalStateGuard:
         self._attrs: list[int | list[int | bytes]] | None = None
         self._enabled = False
 
+        if termios is None:
+            return
         stdin = sys.__stdin__
         if stdin is None:
             return

{comate_cli-0.2.4 → comate_cli-0.2.6}/comate_cli/terminal_agent/event_renderer.py

@@ -32,7 +32,7 @@ from rich.console import RenderableType
 from rich.text import Text
 
 from comate_cli.terminal_agent.models import HistoryEntry, LoadingState
-from comate_cli.terminal_agent.tool_view import summarize_tool_args, resolve_display_tool_name
+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.env_utils import read_env_int
 
 logger = logging.getLogger(__name__)
@@ -111,23 +111,25 @@ def _task_sort_key(task: dict[str, Any]) -> tuple[int, int]:
 
 
 def _format_task_row(task: dict[str, Any]) -> str:
-    task_id = str(task.get("id", "?")).strip() or "?"
+    """格式化单条 task 行。
+
+    符号约定：
+    - ✓ completed
+    - ◼ in_progress
+    - ▢ pending (unblocked)
+    - ▫ pending (blocked) — 视觉相似的中间符号，渲染层统一显示为 ▢ 但应用不同颜色
+    """
     subject = str(task.get("subject", "")).strip() or "(untitled)"
-    owner = str(task.get("owner", "")).strip()
     status = str(task.get("status", "pending")).strip().lower()
     open_blocked_by = task.get("open_blocked_by", [])
-    owner_suffix = f" owner={owner}" if owner else ""
-    blocked_suffix = ""
-    if isinstance(open_blocked_by, list) and open_blocked_by:
-        blocked_suffix = f" blocked by #{','.join(str(item) for item in open_blocked_by)}"
 
     if status == "completed":
-        return f"  ✓ [#{task_id}] {subject}{owner_suffix}"
+        return f"✓ {subject}"
     if status == "in_progress":
-        return f"  ◉ [#{task_id}] {subject}{owner_suffix}"
-    if blocked_suffix:
-        return f"  ◌ [#{task_id}] {subject}{owner_suffix}{blocked_suffix}"
-    return f"  ○ [#{task_id}] {subject}{owner_suffix}"
+        return f"◼ {subject}"
+    if isinstance(open_blocked_by, list) and open_blocked_by:
+        return f"▫ {subject}"
+    return f"▢ {subject}"
 
 
 @dataclass
@@ -154,6 +156,7 @@ class _RunningTool:
     subagent_description: str = ""
     nested_tools: list[tuple[str, _SubagentTool]] = field(default_factory=list)
     show_init: bool = False
+    subagent_model_name: str = ""
 
 
 class EventRenderer:
@@ -162,6 +165,7 @@ class EventRenderer:
     def __init__(self, project_root: Path | None = None) -> None:
         self._history: list[HistoryEntry] = []
         self._running_tools: dict[str, _RunningTool] = {}
+        self._tool_call_args: dict[str, dict[str, Any]] = {}
         self._thinking_content: str = ""
         self._assistant_buffer = ""
         self._loading_state: LoadingState = LoadingState.idle()
@@ -237,6 +241,7 @@ class EventRenderer:
         self._history = []
         self._recent_team_event_keys.clear()
         self._running_tools.clear()
+        self._tool_call_args.clear()
         self._thinking_content = ""
         self._assistant_buffer = ""
         self._loading_state = LoadingState.idle()
@@ -384,10 +389,13 @@ class EventRenderer:
         self._flush_assistant_segment()
         self._history.append(HistoryEntry(entry_type="assistant", text=normalized))
 
-    def tool_panel_entries(self, *, max_lines: int | None = None) -> list[tuple[int, str]]:
+    def tool_panel_entries(
+        self, *, max_lines: int | None = None
+    ) -> list[tuple[int, str | list[tuple[str, str]]]]:
         """Return panel entries for running tools.
 
-        Each entry is a tuple: (indent_level, text_without_dot_prefix).
+        Each entry is a tuple: (indent_level, content).
+        content is either a plain str or a list of (style, text) prompt_toolkit fragments.
         indent_level == 0 means a primary tool line; >0 means nested status.
         indent_level < 0 means a meta line (no dot prefix).
         """
@@ -426,13 +434,23 @@ class EventRenderer:
                     if state.progress_tokens > 0
                     else ""
                 )
-                # 格式：SubagentName(描述)
+                # 格式：SubagentName(描述) · model(dim) · elapsed · tools · tokens
                 subagent_name = state.subagent_name or "Agent"
                 description = state.subagent_description or state.title
                 title = f"{subagent_name}({description})"
                 tool_count = len(state.nested_tools)
                 tool_count_suffix = f" · +{tool_count} tool uses" if tool_count > 0 else ""
-                entries.append((0, f"{title} · {elapsed}{tool_count_suffix}{tokens_suffix}"))
+                rest = f" · {elapsed}{tool_count_suffix}{tokens_suffix}"
+                if state.subagent_model_name:
+                    # Return styled fragments: model_name in dim
+                    frags: list[tuple[str, str]] = [
+                        ("", title),
+                        ("class:dim", f" · {state.subagent_model_name}"),
+                        ("", rest),
+                    ]
+                    entries.append((0, frags))
+                else:
+                    entries.append((0, f"{title}{rest}"))
 
                 # 嵌套工具调用（最多显示最近 3 个）
                 for child_id, child_tool in state.nested_tools[-3:]:
@@ -464,7 +482,7 @@ class EventRenderer:
             return lines
 
         clipped = lines[: normalized_limit - 1]
-        clipped.append(f"  … (+{len(lines) - (normalized_limit - 1)})")
+        clipped.append(f"… (+{len(lines) - (normalized_limit - 1)})")
         return clipped
 
     def full_task_panel_lines(self) -> list[str]:
@@ -495,6 +513,7 @@ class EventRenderer:
         signature: str,
         is_error: bool = False,
         diff_lines: list[str] | None = None,
+        model_name: str = "",
     ) -> None:
         """Append a tool result to history as a static entry (no timer).
 
@@ -502,17 +521,27 @@ class EventRenderer:
             signature: 工具签名，例如 "Read(path=xxx)"
             is_error: 是否为错误结果
             diff_lines: optional diff lines for Edit/MultiEdit
+            model_name: model name for Agent tools (rendered dim)
         """
         sev: Literal["info", "warning", "error"] = "error" if is_error else "info"
         if not is_error and diff_lines and len(diff_lines) > 0:
             self._latest_diff_lines = diff_lines
             text_obj = Text(signature)
+            if model_name:
+                text_obj.append(f" · {model_name}", style="dim")
             text_obj.append("\n")
             text_obj.append(self._render_diff_text(diff_lines, max_lines=self._diff_max_lines))
             self._history.append(
                 HistoryEntry(entry_type="tool_result", text=text_obj, severity="info")
             )
             return
+        if model_name:
+            text_obj = Text(signature)
+            text_obj.append(f" · {model_name}", style="dim")
+            self._history.append(
+                HistoryEntry(entry_type="tool_result", text=text_obj, severity=sev)
+            )
+            return
         self._history.append(
             HistoryEntry(
                 entry_type="tool_result",
@@ -573,14 +602,19 @@ class EventRenderer:
                 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", "")
+
             tool_count = len(state.nested_tools)
-            tool_count_suffix = f" · +{tool_count} tool uses" if tool_count > 0 else ""
-            tokens_suffix = (
-                f" · {_format_tokens(state.progress_tokens)}"
-                if state.progress_tokens > 0
-                else ""
-            )
-            base = f"{task_title}{tool_count_suffix}{tokens_suffix}"
+            base = Text(task_title)
+            if model_name:
+                base.append(f" · {model_name}", style="dim")
+            if tool_count > 0:
+                base.append(f" · +{tool_count} tool uses")
+            if state.progress_tokens > 0:
+                base.append(f" · {_format_tokens(state.progress_tokens)}")
         else:
             display_name = state.display_tool_name or state.tool_name
             summary = state.args_summary
@@ -603,7 +637,10 @@ class EventRenderer:
             diff_lines = metadata.get("diff")
             if isinstance(diff_lines, list) and len(diff_lines) > 0:
                 self._latest_diff_lines = diff_lines
-                text_obj = Text(f"{base}{error_suffix}")
+                if isinstance(base, Text):
+                    text_obj = base
+                else:
+                    text_obj = Text(f"{base}{error_suffix}")
                 text_obj.append("\n")
                 text_obj.append(self._render_diff_text(diff_lines, max_lines=self._diff_max_lines))
                 self._history.append(
@@ -611,7 +648,12 @@ class EventRenderer:
                 )
                 return
 
-        self._history.append(HistoryEntry(entry_type="tool_result", text=f"{base}{error_suffix}", severity=sev))
+        if isinstance(base, Text):
+            if error_suffix:
+                base.append(error_suffix)
+            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev))
+        else:
+            self._history.append(HistoryEntry(entry_type="tool_result", text=f"{base}{error_suffix}", severity=sev))
 
     @staticmethod
     def _render_diff_text(diff_lines: list[str], max_lines: int = 50) -> Text:
@@ -730,7 +772,16 @@ class EventRenderer:
             return
 
         all_completed = all(str(item.get("status", "")).strip().lower() == "completed" for item in normalized)
-        header = "Tasks" if list_id == "default" else f"Tasks · {list_id}"
+        # 标题：显示 ID 最小的 in_progress task 的 subject，否则 "Tasks"
+        in_progress_tasks = [
+            t for t in normalized
+            if str(t.get("status", "")).strip().lower() == "in_progress"
+        ]
+        if in_progress_tasks:
+            in_progress_tasks.sort(key=lambda t: int(t.get("id", 0)))
+            header = str(in_progress_tasks[0].get("subject", "")).strip() or "Tasks"
+        else:
+            header = "Tasks"
         if not all_completed:
             if not self._current_tasks:
                 self._task_started_at_monotonic = time.monotonic()
@@ -776,17 +827,21 @@ class EventRenderer:
 
         for task in tasks:
             line = _format_task_row(task)
-            if line.startswith("  ✓ "):
+            if line.startswith("✓ "):
                 result.append("  ✓ ")
-                result.append(line[4:], style="green strike")
-            elif line.startswith("  ◉ "):
-                result.append("  ◉ ")
-                result.append(line[4:], style="yellow")
-            elif line.startswith("  ◌ "):
-                result.append("  ◌ ")
-                result.append(line[4:], style="dim")
+                result.append(line[2:], style="green strike")
+            elif line.startswith("◼ "):
+                result.append("  ◼ ")
+                result.append(line[2:], style="#F97316")
+            elif line.startswith("▫ "):
+                # blocked pending: display as ▢ + dim
+                result.append("  ▢ ")
+                result.append(line[2:], style="dim")
+            elif line.startswith("▢ "):
+                result.append("  ▢ ")
+                result.append(line[2:])
             else:
-                result.append(line)
+                result.append(f"  {line}")
             result.append("\n")
 
         # 移除末尾的换行
@@ -861,18 +916,15 @@ class EventRenderer:
             case ToolCallEvent(tool=tool_name, args=arguments, tool_call_id=tool_call_id):
                 args_dict = arguments if isinstance(arguments, dict) else {"_raw": str(arguments)}
                 self._thinking_content = ""
-                # Task* / AskUserQuestion / ExitPlanMode: skip normal tool tracking.
-                if tool_name.lower() in ("taskcreate", "tasklist", "taskget", "taskupdate", "askuserquestion", "exitplanmode"):
+                # Store args for ToolResult phase lookup.
+                self._tool_call_args[tool_call_id] = args_dict
+                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):
-                if tool_name.lower() in ("taskcreate", "tasklist", "taskupdate") and not is_error:
-                    # Successful task coordination updates should not spam scrollback.
-                    self._rebuild_loading_line()
-                    return (False, None)
-                if tool_name.lower() in ("askuserquestion", "exitplanmode") and not is_error:
-                    # Success is already visible via UserQuestionEvent / PlanApprovalRequiredEvent.
+                stored_args = self._tool_call_args.pop(tool_call_id, {})
+                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()
                     return (False, None)
@@ -902,6 +954,7 @@ class EventRenderer:
                 status=status,
                 elapsed_ms=elapsed_ms,
                 tokens=tokens,
+                model_name=model_name,
             ):
                 state = self._running_tools.get(tool_call_id)
                 if state is not None:
@@ -914,6 +967,8 @@ class EventRenderer:
                     state.subagent_name = str(subagent_name or "").strip()
                     state.subagent_status = str(status or "").strip()
                     state.subagent_description = str(description or "").strip()
+                    if model_name:
+                        state.subagent_model_name = str(model_name)
                     # 首个有效子事件后移除 init 占位。
                     progress_status = str(status or "").strip().lower()
                     has_activity = bool(tokens and int(tokens) > 0) or bool(

{comate_cli-0.2.4 → comate_cli-0.2.6}/comate_cli/terminal_agent/tool_view.py

@@ -60,6 +60,48 @@ _MAX_FANCY_LINE_LEN = 100
 _ALLOWED_STATUS = {"pending", "in_progress", "completed"}
 _ALLOWED_PRIORITY = {"high", "medium", "low"}
 
+# Tools that are always hidden from scrollback (have dedicated event channels).
+_ALWAYS_HIDDEN_TOOLS: frozenset[str] = frozenset({"askuserquestion", "exitplanmode"})
+
+# Task coordination tools hidden from scrollback unless erroring.
+_SILENT_TASK_TOOLS: frozenset[str] = frozenset({"tasklist", "taskget"})
+
+
+def should_show_tool_in_scrollback(
+    tool_name: str,
+    args: dict[str, Any],
+    is_result: bool = False,
+    is_error: bool = False,
+) -> bool:
+    """Determine whether a tool call/result should appear in scrollback.
+
+    Centralises the visibility rules so that both the live event pipeline
+    (event_renderer) and the resume replay pipeline (history_sync) share
+    one source of truth.
+    """
+    lowered = tool_name.lower()
+
+    # AskUserQuestion / ExitPlanMode: only show errors.
+    if lowered in _ALWAYS_HIDDEN_TOOLS:
+        return is_result and is_error
+
+    # TaskCreate: always visible.
+    if lowered == "taskcreate":
+        return True
+
+    # TaskUpdate: visible only when status=completed, or on error.
+    if lowered == "taskupdate":
+        if str(args.get("status", "")).lower() == "completed":
+            return True
+        return is_result and is_error
+
+    # TaskList / TaskGet: only show errors.
+    if lowered in _SILENT_TASK_TOOLS:
+        return is_result and is_error
+
+    # All other tools: always visible.
+    return True
+
 
 def _parse_todos_value(value: Any) -> list[dict[str, Any]] | None:
     if isinstance(value, list):

{comate_cli-0.2.4 → comate_cli-0.2.6}/comate_cli/terminal_agent/tui.py

@@ -75,6 +75,8 @@ from comate_cli.terminal_agent.tui_parts import (
 
 logger = logging.getLogger(__name__)
 
+_TASK_POLL_INTERVAL_S = 2.0
+
 
 class TerminalAgentTUI(
     KeyBindingsMixin,
@@ -96,6 +98,7 @@ class TerminalAgentTUI(
         except Exception:
             pass
         self._renderer = renderer
+        self._task_poll_next_at = time.monotonic() + _TASK_POLL_INTERVAL_S
         self._rewind_store = RewindStore(session=self._session, project_root=Path.cwd())
 
         # Team inbox 消息直连 scrollback（绕开 session_event_queue，实现实时显示）
@@ -1037,6 +1040,34 @@ class TerminalAgentTUI(
         self._sync_focus_for_mode()
         self._render_dirty = True
 
+    def _fetch_tasks_from_store(self) -> tuple[list[dict], str] | None:
+        """从 TaskStore 读取最新 task 列表（纯 I/O，线程安全）。
+
+        返回 (task_dicts, list_id) 或 None。
+        不修改任何共享状态——状态更新由调用方在主线程完成。
+        """
+        try:
+            agent = getattr(self._session, "_agent", None)
+            if agent is None:
+                return None
+            store = getattr(agent, "_task_store", None)
+            if store is None:
+                return None
+            tasks = store.list_tasks()
+            if not tasks:
+                return None
+            # 转换 TaskItem 为 dict（与 chat_session.py 格式一致）
+            task_dicts: list[dict] = []
+            for task in tasks:
+                payload = task.model_dump(mode="json")
+                payload["open_blocked_by"] = store.get_open_blocked_by(task.id)
+                task_dicts.append(payload)
+            list_id = store.list_id_value()
+            return task_dicts, list_id
+        except Exception:
+            logger.debug("task store fetch failed", exc_info=True)
+            return None
+
     async def _ui_tick(self) -> None:
         try:
             while not self._closing:
@@ -1091,6 +1122,17 @@ class TerminalAgentTUI(
                     or self._renderer.has_running_tools()
                 )
                 sleep_s = 1 / 6 if fast else 1 / 4
+
+                # 定时轮询 TaskStore 刷新 task 面板
+                now_poll = time.monotonic()
+                if now_poll >= self._task_poll_next_at:
+                    self._task_poll_next_at = now_poll + _TASK_POLL_INTERVAL_S
+                    poll_result = await asyncio.to_thread(self._fetch_tasks_from_store)
+                    if poll_result is not None:
+                        task_dicts, list_id = poll_result
+                        self._renderer._update_tasks(task_dicts, list_id=list_id)
+                        self._render_dirty = True
+
                 await asyncio.sleep(sleep_s)
         except asyncio.CancelledError:
             return

{comate_cli-0.2.4 → comate_cli-0.2.6}/comate_cli/terminal_agent/tui_parts/history_sync.py

@@ -18,6 +18,7 @@ from comate_cli.terminal_agent.history_printer import (
 from comate_cli.terminal_agent.logo import print_logo
 from comate_cli.terminal_agent.markdown_render import render_markdown_to_plain
 from comate_cli.terminal_agent.models import HistoryEntry
+from comate_cli.terminal_agent.tool_view import should_show_tool_in_scrollback
 
 console = Console()
 logger = logging.getLogger(__name__)
@@ -76,6 +77,7 @@ class HistorySyncMixin:
 
         # 维护 tool_call_id 映射，用于匹配工具调用和结果
         tool_call_info: dict[str, tuple[str, str]] = {}  # tool_call_id → (tool_name, signature)
+        tool_call_args: dict[str, dict[str, Any]] = {}
 
         for item in history:
             if item.item_type == ItemType.USER_MESSAGE:
@@ -103,6 +105,7 @@ class HistorySyncMixin:
                         signature = self._build_resume_tool_signature(tool_name, args_dict)
                         # 存储映射，不调用 restore_tool_call（避免加入 _running_tools）
                         tool_call_info[tc.id] = (tool_name, signature)
+                        tool_call_args[tc.id] = args_dict
 
                 # 显示 assistant text
                 assistant_text = self._extract_assistant_text(item).strip()
@@ -127,11 +130,18 @@ class HistorySyncMixin:
                     tool_name = getattr(message, "tool_name", item.tool_name or "UnknownTool")
                     signature = f"{tool_name}()"
 
+                # Apply shared visibility filter.
+                resume_args = tool_call_args.get(tool_call_id, {}) if tool_call_id else {}
+                if not should_show_tool_in_scrollback(tool_name, resume_args, is_result=True, is_error=is_error):
+                    continue
+
+                # Extract metadata from ContextItem
+                item_metadata = getattr(item, "metadata", {}) or {}
+
                 # Extract diff from raw_envelope for Edit/MultiEdit
                 diff_lines: list[str] | None = None
                 if tool_name in ("Edit", "MultiEdit") and not is_error:
-                    raw_envelope = getattr(item, "metadata", {}) or {}
-                    envelope = raw_envelope.get("tool_raw_envelope")
+                    envelope = item_metadata.get("tool_raw_envelope")
                     if isinstance(envelope, dict):
                         data = envelope.get("data", {})
                         if isinstance(data, dict):
@@ -139,11 +149,19 @@ class HistorySyncMixin:
                             if isinstance(diff, list) and len(diff) > 0:
                                 diff_lines = diff
 
+                # Extract model_name for Agent tools
+                model_name = ""
+                if tool_name.lower() == "agent":
+                    exec_meta = item_metadata.get("tool_execution_meta")
+                    if isinstance(exec_meta, dict):
+                        model_name = exec_meta.get("model_name", "")
+
                 # 直接追加静态 HistoryEntry（无计时器）
                 self._renderer.append_static_tool_result(
                     signature,
                     is_error,
                     diff_lines=diff_lines,
+                    model_name=model_name,
                 )
                 continue
 

{comate_cli-0.2.4 → comate_cli-0.2.6}/comate_cli/terminal_agent/tui_parts/render_panels.py

@@ -239,7 +239,7 @@ class RenderPanelsMixin:
             )
             if len(all_lines) > len(collapsed_lines) and collapsed_lines:
                 last_line = collapsed_lines[-1]
-                if last_line.startswith("  … (+"):
+                if last_line.startswith("… (+"):
                     collapsed_lines[-1] = f"{last_line}, Ctrl+Y to expand"
             return collapsed_lines
 
@@ -296,15 +296,23 @@ class RenderPanelsMixin:
                 fragments.extend(self._rich_text_to_pt_fragments(renderable))
                 fragments.append(("", "\n"))
 
+            dim_style = "fg:#6B7280"
             last_index = len(entries) - 1
             for idx, (indent, line) in enumerate(entries):
                 if indent < 0:
                     clipped = fit_single_line(line, width - 1)
                     fragments.append((nested_style, clipped))
                 elif indent == 0:
-                    clipped = fit_single_line(line, max(width - 2, 8))
-                    fragments.append((dot_style, f"{dot_glyph} "))
-                    fragments.append((primary_style, clipped))
+                    if isinstance(line, list):
+                        # Styled fragments from tool_panel_entries
+                        fragments.append((dot_style, f"{dot_glyph} "))
+                        for frag_style, frag_text in line:
+                            resolved = dim_style if frag_style == "class:dim" else (frag_style or primary_style)
+                            fragments.append((resolved, frag_text))
+                    else:
+                        clipped = fit_single_line(line, max(width - 2, 8))
+                        fragments.append((dot_style, f"{dot_glyph} "))
+                        fragments.append((primary_style, clipped))
                 else:
                     padding = "  " * indent
                     clipped = fit_single_line(line, max(width - get_cwidth(padding), 8))
@@ -558,13 +566,42 @@ class RenderPanelsMixin:
                 if title_elapsed_suffix:
                     fragments.append(("fg:#6B7280", title_elapsed_suffix))
             else:
-                clipped = fit_single_line(line, width - 1)
-                style = "fg:#CBD5E1"
-                if "✓" in line:
-                    style = "fg:#86EFAC"
-                elif "◉" in line:
-                    style = "fg:#FDE68A"
-                fragments.append((style, clipped))
+                clipped = fit_single_line(line, width - 3)  # 留空间给 prefix + space
+                # prefix 列：第一条任务行用 ⎿，后续用空格
+                is_first_task_row = idx == 1
+                prefix_char = "⎿" if is_first_task_row else " "
+                prefix_style = "fg:#555555"
+
+                # 解析符号和文本，应用分色
+                if clipped.startswith("✓ "):
+                    symbol, text = "✓", clipped[2:]
+                    symbol_style = "fg:#86EFAC"
+                    text_style = "fg:#6B7280 strike"
+                elif clipped.startswith("◼ "):
+                    symbol, text = "◼", clipped[2:]
+                    symbol_style = "fg:#F97316"
+                    text_style = "fg:#E2E8F0"
+                elif clipped.startswith("▫ "):
+                    # blocked pending: ▫ 是中间符号，渲染时显示为 ▢
+                    symbol, text = "▢", clipped[2:]
+                    symbol_style = "fg:#4B5563"
+                    text_style = "fg:#4B5563"
+                elif clipped.startswith("▢ "):
+                    symbol, text = "▢", clipped[2:]
+                    symbol_style = "fg:#6B7280"
+                    text_style = "fg:#6B7280"
+                else:
+                    # 溢出行 "… (+N)" 等
+                    symbol, text = "", clipped
+                    symbol_style = ""
+                    text_style = "fg:#6B7280"
+
+                fragments.append((prefix_style, prefix_char))
+                fragments.append(("", " "))
+                if symbol:
+                    fragments.append((symbol_style, symbol))
+                    fragments.append(("", " "))
+                fragments.append((text_style, text))
             if idx != last_index:
                 fragments.append(("", "\n"))
         return fragments

{comate_cli-0.2.4 → comate_cli-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.2.4"
+version = "0.2.6"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11"

{comate_cli-0.2.4 → comate_cli-0.2.6}/tests/test_completion_status_panel.py

@@ -68,7 +68,7 @@ class _FakeRenderer:
         if len(self.todo_lines) <= max_lines:
             return list(self.todo_lines)
         clipped = list(self.todo_lines[: max_lines - 1])
-        clipped.append(f"  … (+{len(self.todo_lines) - (max_lines - 1)})")
+        clipped.append(f"… (+{len(self.todo_lines) - (max_lines - 1)})")
         return clipped
 
     def todo_all_lines(self) -> list[str]: