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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.2.4
+Version: 0.2.5
 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.5}/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
@@ -162,6 +164,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 +240,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()
@@ -464,7 +468,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]:
@@ -730,7 +734,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 +789,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 +878,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)

{comate_cli-0.2.4 → comate_cli-0.2.5}/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.5}/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.5}/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,6 +130,11 @@ 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 diff from raw_envelope for Edit/MultiEdit
                 diff_lines: list[str] | None = None
                 if tool_name in ("Edit", "MultiEdit") and not is_error:

{comate_cli-0.2.4 → comate_cli-0.2.5}/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
 
@@ -558,13 +558,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.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.2.4"
+version = "0.2.5"
 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.5}/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]:

{comate_cli-0.2.4 → comate_cli-0.2.5}/tests/test_event_renderer.py

@@ -233,7 +233,7 @@ class TestEventRenderer(unittest.TestCase):
         self.assertLessEqual(len(task_lines), 6)
         self.assertIn("…", task_lines[-1])
 
-    def test_task_header_uses_list_id_without_status_summary(self) -> None:
+    def test_task_header_uses_in_progress_subject_without_list_id(self) -> None:
         renderer = EventRenderer()
         renderer.start_turn()
         renderer.handle_event(
@@ -248,7 +248,9 @@ class TestEventRenderer(unittest.TestCase):
 
         task_lines = renderer.task_lines()
         self.assertTrue(task_lines)
-        self.assertEqual(task_lines[0], "Tasks · release")
+        # Title shows the in_progress task's subject, not list_id
+        self.assertEqual(task_lines[0], "b")
+        self.assertNotIn("release", task_lines[0])
         self.assertNotIn("completed", task_lines[0])
         self.assertNotIn("in_progress", task_lines[0])
 
@@ -275,9 +277,10 @@ class TestEventRenderer(unittest.TestCase):
         self.assertIn("open-2", joined)
         self.assertIn("open-3", joined)
         self.assertNotIn("done-2", joined)
-        self.assertTrue(lines[-1].startswith("  … (+"))
+        self.assertTrue(lines[-1].startswith("… (+"))
 
-    def test_task_row_renders_owner_when_present(self) -> None:
+    def test_task_row_omits_owner_from_display(self) -> None:
+        """Owner field is no longer shown in task rows (visual redesign)."""
         renderer = EventRenderer()
         renderer.start_turn()
         renderer.handle_event(
@@ -304,8 +307,8 @@ class TestEventRenderer(unittest.TestCase):
 
         lines = renderer.task_panel_lines(max_lines=6)
         joined = "\n".join(lines)
-        self.assertIn("claim task ownership owner=andy", joined)
-        self.assertNotIn("keep row compact owner=", joined)
+        self.assertIn("claim task ownership", joined)
+        self.assertNotIn("owner=", joined)
 
     def test_team_task_row_omits_empty_owner_suffix(self) -> None:
         renderer = EventRenderer()
@@ -618,5 +621,59 @@ class TestEventRenderer(unittest.TestCase):
         self.assertIn("step from file", assistant_entries[-1].text)
 
 
+class TestTaskToolScrollbackDisplay(unittest.TestCase):
+    """Verify TaskCreate and TaskUpdate(completed) appear in scrollback."""
+
+    def test_taskcreate_toolcall_produces_history_entry(self) -> None:
+        renderer = EventRenderer()
+        renderer.start_turn()
+        renderer.handle_event(ToolCallEvent(tool="TaskCreate", args={"subject": "do X"}, tool_call_id="tc1"))
+        renderer.handle_event(ToolResultEvent(tool="TaskCreate", result="ok", tool_call_id="tc1", is_error=False))
+        entries = [e for e in renderer.history_entries() if e.entry_type == "tool_result"]
+        self.assertEqual(len(entries), 1)
+        self.assertIn("TaskCreate", str(entries[0].text))
+
+    def test_taskupdate_completed_produces_history_entry(self) -> None:
+        renderer = EventRenderer()
+        renderer.start_turn()
+        renderer.handle_event(ToolCallEvent(tool="TaskUpdate", args={"taskId": "1", "status": "completed"}, tool_call_id="tc2"))
+        renderer.handle_event(ToolResultEvent(tool="TaskUpdate", result="ok", tool_call_id="tc2", is_error=False))
+        entries = [e for e in renderer.history_entries() if e.entry_type == "tool_result"]
+        self.assertEqual(len(entries), 1)
+        self.assertIn("TaskUpdate", str(entries[0].text))
+
+    def test_taskupdate_in_progress_hidden_from_scrollback(self) -> None:
+        renderer = EventRenderer()
+        renderer.start_turn()
+        renderer.handle_event(ToolCallEvent(tool="TaskUpdate", args={"taskId": "1", "status": "in_progress"}, tool_call_id="tc3"))
+        renderer.handle_event(ToolResultEvent(tool="TaskUpdate", result="ok", tool_call_id="tc3", is_error=False))
+        entries = [e for e in renderer.history_entries() if e.entry_type == "tool_result"]
+        self.assertEqual(len(entries), 0)
+
+    def test_tasklist_hidden_from_scrollback(self) -> None:
+        renderer = EventRenderer()
+        renderer.start_turn()
+        renderer.handle_event(ToolCallEvent(tool="TaskList", args={}, tool_call_id="tc4"))
+        renderer.handle_event(ToolResultEvent(tool="TaskList", result="ok", tool_call_id="tc4", is_error=False))
+        entries = [e for e in renderer.history_entries() if e.entry_type == "tool_result"]
+        self.assertEqual(len(entries), 0)
+
+    def test_tasklist_error_shown_in_scrollback(self) -> None:
+        renderer = EventRenderer()
+        renderer.start_turn()
+        renderer.handle_event(ToolCallEvent(tool="TaskList", args={}, tool_call_id="tc5"))
+        renderer.handle_event(ToolResultEvent(tool="TaskList", result="store error", tool_call_id="tc5", is_error=True))
+        entries = [e for e in renderer.history_entries() if e.entry_type == "tool_result"]
+        self.assertEqual(len(entries), 1)
+
+    def test_reset_history_view_clears_tool_call_args(self) -> None:
+        renderer = EventRenderer()
+        renderer.start_turn()
+        renderer.handle_event(ToolCallEvent(tool="TaskCreate", args={"subject": "x"}, tool_call_id="tc6"))
+        self.assertTrue(renderer._tool_call_args)
+        renderer.reset_history_view()
+        self.assertFalse(renderer._tool_call_args)
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)

comate_cli-0.2.5/tests/test_task_panel_format.py

@@ -0,0 +1,96 @@
+"""Tests for _format_task_row after visual redesign."""
+from __future__ import annotations
+
+from comate_cli.terminal_agent.event_renderer import _format_task_row
+
+
+def test_completed_task_row():
+    task = {"id": "1", "subject": "Set up project", "status": "completed", "owner": "alice", "open_blocked_by": []}
+    result = _format_task_row(task)
+    assert result == "✓ Set up project"
+    assert "[#" not in result
+    assert "owner=" not in result
+
+
+def test_in_progress_task_row():
+    task = {"id": "2", "subject": "Implement auth", "status": "in_progress", "owner": "bob", "open_blocked_by": []}
+    result = _format_task_row(task)
+    assert result == "◼ Implement auth"
+    assert "[#" not in result
+    assert "owner=" not in result
+
+
+def test_pending_unblocked_task_row():
+    task = {"id": "3", "subject": "Write tests", "status": "pending", "owner": "", "open_blocked_by": []}
+    result = _format_task_row(task)
+    assert result == "▢ Write tests"
+
+
+def test_pending_blocked_task_row():
+    """Blocked pending uses ▫ (U+25AB) as intermediate symbol for color differentiation."""
+    task = {"id": "4", "subject": "Deploy", "status": "pending", "owner": "", "open_blocked_by": ["1", "2"]}
+    result = _format_task_row(task)
+    assert result == "▫ Deploy"
+    assert "blocked by" not in result
+    assert "owner=" not in result
+
+
+def test_untitled_task_row():
+    task = {"id": "5", "subject": "", "status": "pending", "owner": "", "open_blocked_by": []}
+    result = _format_task_row(task)
+    assert result == "▢ (untitled)"
+
+
+from comate_cli.terminal_agent.event_renderer import EventRenderer
+
+
+def _make_renderer_for_title_test() -> EventRenderer:
+    """创建最小化 EventRenderer 用于测试 _update_tasks 的标题逻辑。"""
+    renderer = object.__new__(EventRenderer)
+    renderer._current_tasks = []
+    renderer._current_task_title = None
+    renderer._task_started_at_monotonic = None
+    renderer._history = []
+    return renderer
+
+
+def test_title_shows_in_progress_subject():
+    renderer = _make_renderer_for_title_test()
+    tasks = [
+        {"id": "1", "subject": "Set up project", "status": "completed", "open_blocked_by": []},
+        {"id": "2", "subject": "Implement auth", "status": "in_progress", "open_blocked_by": []},
+        {"id": "3", "subject": "Write tests", "status": "pending", "open_blocked_by": []},
+    ]
+    renderer._update_tasks(tasks, list_id="default")
+    assert renderer._current_task_title == "Implement auth"
+
+
+def test_title_shows_smallest_id_in_progress():
+    renderer = _make_renderer_for_title_test()
+    tasks = [
+        {"id": "3", "subject": "Task C", "status": "in_progress", "open_blocked_by": []},
+        {"id": "1", "subject": "Task A", "status": "in_progress", "open_blocked_by": []},
+        {"id": "2", "subject": "Task B", "status": "pending", "open_blocked_by": []},
+    ]
+    renderer._update_tasks(tasks, list_id="default")
+    assert renderer._current_task_title == "Task A"
+
+
+def test_title_falls_back_to_tasks_when_no_in_progress():
+    renderer = _make_renderer_for_title_test()
+    tasks = [
+        {"id": "1", "subject": "Set up project", "status": "pending", "open_blocked_by": []},
+        {"id": "2", "subject": "Write tests", "status": "pending", "open_blocked_by": []},
+    ]
+    renderer._update_tasks(tasks, list_id="default")
+    assert renderer._current_task_title == "Tasks"
+
+
+def test_title_ignores_list_id():
+    renderer = _make_renderer_for_title_test()
+    tasks = [
+        {"id": "1", "subject": "Task A", "status": "pending", "open_blocked_by": []},
+    ]
+    renderer._update_tasks(tasks, list_id="team-alpha")
+    assert renderer._current_task_title == "Tasks"
+    assert "team-alpha" not in (renderer._current_task_title or "")

{comate_cli-0.2.4 → comate_cli-0.2.5}/tests/test_task_panel_key_bindings.py

@@ -36,14 +36,14 @@ class _StubRenderer:
         self.active_todos = True
         self.todo_lines = [
             "Tasks",
-            "  ◉ task-1",
-            "  ○ task-2",
-            "  ○ task-3",
-            "  ○ task-4",
-            "  ○ task-5",
-            "  ○ task-6",
-            "  ○ task-7",
-            "  ○ task-8",
+            "◼ task-1",
+            "▢ task-2",
+            "▢ task-3",
+            "▢ task-4",
+            "▢ task-5",
+            "▢ task-6",
+            "▢ task-7",
+            "▢ task-8",
         ]
 
     def has_active_todos(self) -> bool: