@scemoon/cdh 1.0.0 → 1.0.3

package/onecode/agent/onecode_agent_acp.py

@@ -42,6 +42,27 @@ def debug_log(*args, **kwargs):
     else:
         print("[onecode]", *args, file=sys.stderr, flush=True)
 
+
+_CRASH_LOG_DIR = Path.home() / ".cdh" / "logs"
+
+
+def _dump_crash(context: str) -> None:
+    """Write traceback to ``~/.cdh/logs/cdh_crash.log`` so it survives subprocess exit."""
+    import os
+    import traceback
+    now = __import__("datetime").datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+    _CRASH_LOG_DIR.mkdir(parents=True, exist_ok=True)
+    path = _CRASH_LOG_DIR / "cdh_crash.log"
+    try:
+        lines = [f"=== crash at {now} context={context} ===\n"]
+        for tb_line in traceback.format_exc().splitlines(True):
+            lines.append(tb_line)
+        with open(os.fspath(path), "a", encoding="utf-8") as f:
+            f.writelines(lines)
+    except Exception:
+        pass
+
+
 from onecode.agent.cdh_loader import CdhProjectLoader
 from onecode.agent.engine import AgentEngine
 from onecode.agent.permissions_store import PermissionStore
@@ -82,7 +103,7 @@ _CATEGORY_TO_ACP_KIND: dict[str, str] = {
     ToolCategory.WEB_FETCH: "fetch",
     ToolCategory.WEB_SEARCH: "search",
     ToolCategory.TASK: "other",
-    ToolCategory.TASK_MGMT: "other",
+    ToolCategory.TODO_MGMT: "other",
     ToolCategory.INTERACTION: "other",
     ToolCategory.UNKNOWN: "other",
 }
@@ -315,8 +336,8 @@ def _build_tool_call_content(name: str | None, arguments: dict) -> list:
         return []
 
     _HEADER_ONLY_TOOLS = frozenset({
-        "TaskCreate", "TaskGet", "TaskList", "TaskUpdate", "TaskOutput", "TaskStop",
-        "TodoCreate", "TodoList", "TodoComplete", "Glob",
+        "TodoCreate", "TodoGet", "TodoList", "TodoUpdate", "TodoOutput", "TodoStop",
+        "Glob", "Spawn",
     })
     if name in _HEADER_ONLY_TOOLS:
         return []
@@ -421,11 +442,11 @@ def _format_tui_display_text(result_text: str, tool_name: str = "") -> str:
     other success results fall through to a compact view of the rest
     of the dict.
 
-    Task / Todo tools (TaskCreate, TaskUpdate, TaskList, …) are special-
+    Todo tools (TodoCreate, TodoUpdate, TodoList, …) are special-
     cased: their verbose ``{"task": {...}}`` / ``{"tasks": [...]}`` results
     are collapsed to a single concise marker (``✓ updated``) since the
     LLM's tool-call args already show what the agent did, and re-printing
-    the full task object after every call clutters the conversation view.
+    the full todo object after every call clutters the conversation view.
     """
     if not result_text:
         return ""
@@ -440,9 +461,9 @@ def _format_tui_display_text(result_text: str, tool_name: str = "") -> str:
     # Read: show actual file content (code fence + language wrapping in _emit_tool_result)
     if tool_name == "Read":
         return parsed.get("content", "")
-    # Task / Todo tools: collapse verbose state echoes to one-liner.
+    # Todo tools: collapse verbose state echoes to one-liner.
     if tool_name in _STATUS_ONLY_TOOLS:
-        return ""
+        return "✓ updated"
     if parsed.get("success") is True:
         if path := parsed.get("path"):
             return f"✓ {path}"
@@ -457,11 +478,12 @@ def _format_tui_display_text(result_text: str, tool_name: str = "") -> str:
 
 
 _STATUS_ONLY_TOOLS = frozenset({
-    "TaskCreate",
-    "TaskUpdate",
-    "TaskStop",
     "TodoCreate",
-    "TodoComplete",
+    "TodoGet",
+    "TodoList",
+    "TodoUpdate",
+    "TodoOutput",
+    "TodoStop",
 })
 
 
@@ -781,8 +803,12 @@ class CDHACPAdapter:
 
     def send_notification(self, method: str, params: dict):
         """Send a JSONRPC notification to A2TUI."""
-        notification = {"jsonrpc": "2.0", "method": method, "params": params}
-        print(json.dumps(notification), flush=True)
+        try:
+            notification = {"jsonrpc": "2.0", "method": method, "params": params}
+            print(json.dumps(notification), flush=True)
+        except (TypeError, ValueError, OSError) as e:
+            _dump_crash("send_notification")
+            debug_log("send_notification failed: %s", e)
 
     def send_request(self, method: str, params: dict) -> asyncio.Future[dict]:
         """Send a JSONRPC request to A2TUI and return a Future for the response."""
@@ -791,7 +817,13 @@ class CDHACPAdapter:
         future: asyncio.Future[dict] = asyncio.Future()
         self._pending_requests[req_id] = future
         request = {"jsonrpc": "2.0", "method": method, "params": params, "id": req_id}
-        print(json.dumps(request), flush=True)
+        try:
+            print(json.dumps(request), flush=True)
+        except (TypeError, ValueError, OSError) as e:
+            _dump_crash("send_request")
+            debug_log("send_request failed: %s", e)
+            if not future.done():
+                future.set_exception(e)
         return future
 
     def resolve_pending_request(self, req_id: str, result: dict) -> bool:
@@ -827,6 +859,10 @@ class CDHACPAdapter:
 
     def _emit_tool_result(self, block: ToolResult) -> None:
         """Send a tool_result as a tool_call_update, accumulating with existing content."""
+        # Spawn results are rendered as SubAgent widgets via
+        # _replay_tool_or_subagent → subagent_start/chunk/end events.
+        if self.tool_calls.get(block.tool_use_id, {}).get("_tool_name") == "Spawn":
+            return
         # Look up tool name from the tracked tool_calls entry
         tool_name = self.tool_calls.get(block.tool_use_id, {}).get("title", "")
         # Title may be like "Bash: ls -la" — keep just the leading tool name
@@ -844,7 +880,7 @@ class CDHACPAdapter:
                 if isinstance(parsed, dict) and parsed.get("success") is True:
                     current_title = self.tool_calls[block.tool_use_id].get("title", "")
                     if ":" not in current_title:
-                        if tool_name in ("TaskCreate", "TaskUpdate"):
+                        if tool_name in ("TodoCreate", "TodoUpdate"):
                             task_info = parsed.get("task", {})
                             if isinstance(task_info, dict):
                                 if subject := task_info.get("subject", ""):
@@ -895,6 +931,58 @@ class CDHACPAdapter:
             }
         self.send_session_update(self.tool_calls[block.tool_use_id])
 
+    def _replay_tool_or_subagent(self, tool_use_id: str, content: str, is_error: bool) -> None:
+        """Replay a tool result — subagent events for Task, tool_call_update otherwise."""
+        tc = self.tool_calls.get(tool_use_id)
+        if tc and tc.get("_tool_name") == "Spawn":
+            args = tc.get("_tool_args", {})
+            agent_type = args.get("agent_type", "general")
+            prompt = args.get("prompt", "")
+            self.send_session_update({
+                "sessionUpdate": "subagent_start",
+                "subagentId": tool_use_id,
+                "agentType": agent_type,
+                "prompt": prompt,
+            })
+            if content:
+                self.send_session_update({
+                    "sessionUpdate": "subagent_chunk",
+                    "subagentId": tool_use_id,
+                    "text": content,
+                })
+            self.send_session_update({
+                "sessionUpdate": "subagent_end",
+                "subagentId": tool_use_id,
+                "agentType": agent_type,
+            })
+        else:
+            tr = ToolResult(
+                tool_use_id=tool_use_id,
+                content=content,
+                is_error=is_error,
+            )
+            self._emit_tool_result(tr)
+
+    def _emit_plan_update_to_tui(self) -> None:
+        """Send a `plan` session update built from current todo state.
+
+        Used right after ``session_load`` so the TUI Plan widget shows the
+        resumed todos immediately, without waiting for the user to
+        type a new prompt.  Delegates dedupe to the engine's
+        ``_emit_plan_update`` so the session-resume snapshot and the
+        per-turn snapshot share a single cache.
+        """
+        tm = getattr(self.agent, "_todo_manager", None)
+        if tm is None:
+            return
+        if not tm.list_todos():
+            return
+        for event in self.agent._emit_plan_update():
+            self.send_session_update({
+                "sessionUpdate": "plan",
+                "entries": event.plan_entries,
+            })
+
     async def initialize(self, protocol_version: int, client_capabilities: dict, client_info: dict):
         """Handle ACP initialize."""
         return {
@@ -944,7 +1032,7 @@ class CDHACPAdapter:
         self.session_id = session.id
 
         # Restore tasks from project .cdh/ if available
-        self.agent.load_tasks_from_project()
+        self.agent.load_todos_from_project()
 
         self._send_available_commands()
 
@@ -969,7 +1057,11 @@ class CDHACPAdapter:
         self._send_available_commands()
 
         # Also restore tasks from project .cdh/ as fallback / supplement
-        self.agent.load_tasks_from_project()
+        self.agent.load_todos_from_project()
+
+        # Surface loaded tasks to the TUI Plan widget so the user sees
+        # pending work without having to send a new message first.
+        self._emit_plan_update_to_tui()
 
         if not loaded:
             return {"modes": _DEFAULT_MODES}
@@ -1020,22 +1112,18 @@ class CDHACPAdapter:
                         elif block.name == "Bash":
                             cmd = str(args.get("command", ""))
                             title = f"Bash: {cmd}"
-                        elif block.name == "TaskCreate":
+                        elif block.name == "TodoCreate":
                             subject = str(args.get("subject", ""))
                             if subject:
-                                title = f"TaskCreate: {subject}"
-                        elif block.name == "TaskUpdate":
+                                title = f"TodoCreate: {subject}"
+                        elif block.name == "TodoUpdate":
                             subject = str(args.get("subject", ""))
                             if subject:
-                                title = f"TaskUpdate: {subject}"
-                        elif block.name in ("TaskGet", "TaskStop", "TaskOutput"):
+                                title = f"TodoUpdate: {subject}"
+                        elif block.name in ("TodoGet", "TodoStop", "TodoOutput"):
                             tid = str(args.get("taskId", args.get("task_id", "")))
                             if tid:
                                 title = f"{block.name}: {tid}"
-                        elif block.name == "TodoCreate":
-                            text = str(args.get("text", ""))
-                            if text:
-                                title = f"TodoCreate: {text[:40]}"
                         elif block.name == "Glob":
                             pattern = str(args.get("pattern", ""))
                             if pattern:
@@ -1050,7 +1138,11 @@ class CDHACPAdapter:
                             "_tool_name": block.name,
                             "_tool_args": block.arguments or {},
                         }
-                        self.send_session_update(self.tool_calls[block.id])
+                        # Skip sending tool_call for Task tools — SubAgent widget
+                        # is rendered via subagent_start/subagent_chunk/subagent_end
+                        # when the corresponding tool_result is processed below.
+                        if block.name != "Spawn":
+                            self.send_session_update(self.tool_calls[block.id])
                     elif isinstance(block, ToolResult):
                         self._emit_tool_result(block)
                     elif isinstance(block, SubAgentBlock):
@@ -1062,6 +1154,7 @@ class CDHACPAdapter:
                             "sessionUpdate": "subagent_start",
                             "subagentId": block.id,
                             "agentType": block.agent_type,
+                            "prompt": block.prompt,
                         })
                         if block.result:
                             self.send_session_update({
@@ -1078,19 +1171,17 @@ class CDHACPAdapter:
                 if isinstance(content, list):
                     for item in content:
                         if isinstance(item, dict) and item.get("type") == "tool_result":
-                            tr = ToolResult(
-                                tool_use_id=item.get("tool_use_id", ""),
-                                content=item.get("content", ""),
-                                is_error=item.get("is_error", False),
+                            self._replay_tool_or_subagent(
+                                item.get("tool_use_id", ""),
+                                item.get("content", ""),
+                                item.get("is_error", False),
                             )
-                            self._emit_tool_result(tr)
                 elif isinstance(content, dict) and content.get("type") == "tool_result":
-                    tr = ToolResult(
-                        tool_use_id=content.get("tool_use_id", ""),
-                        content=content.get("content", ""),
-                        is_error=content.get("is_error", False),
+                    self._replay_tool_or_subagent(
+                        content.get("tool_use_id", ""),
+                        content.get("content", ""),
+                        content.get("is_error", False),
                     )
-                    self._emit_tool_result(tr)
 
         return {
             "modes": {
@@ -1422,6 +1513,9 @@ class CDHACPAdapter:
         _ARGS_THROTTLE_CHARS = 50
 
         def _on_tool_call_delta(call_id: str, name: str, args_delta: str) -> None:
+            # Skip Spawn — SubAgent widget handles display via subagent_* events
+            if name == "Spawn":
+                return
             if args_delta:
                 _incremental_args[call_id] = _incremental_args.get(call_id, "") + args_delta
                 display_args = _incremental_args[call_id]
@@ -1466,7 +1560,10 @@ class CDHACPAdapter:
                         "content": existing.get("content", []),
                         "_tool_name": event.tool_name,
                     }
-                    self.send_session_update(self.tool_calls[event.tool_id])
+                        # Skip sending tool_call for Spawn tools — SubAgent widget
+                    # handles the display via subagent_start events.
+                    if event.tool_name != "Spawn":
+                        self.send_session_update(self.tool_calls[event.tool_id])
                 elif event.type == StreamEventType.TOOL_CALL_COMPLETE:
                     if event.tool_id in self.tool_calls:
                         title = event.tool_name
@@ -1476,22 +1573,18 @@ class CDHACPAdapter:
                             elif event.tool_name == "Bash":
                                 cmd = str(event.tool_args.get("command", ""))
                                 title = f"Bash: {cmd}"
-                            elif event.tool_name == "TaskCreate":
+                            elif event.tool_name == "TodoCreate":
                                 subject = str(event.tool_args.get("subject", ""))
                                 if subject:
-                                    title = f"TaskCreate: {subject}"
-                            elif event.tool_name == "TaskUpdate":
+                                    title = f"TodoCreate: {subject}"
+                            elif event.tool_name == "TodoUpdate":
                                 subject = str(event.tool_args.get("subject", ""))
                                 if subject:
-                                    title = f"TaskUpdate: {subject}"
-                            elif event.tool_name in ("TaskGet", "TaskStop", "TaskOutput"):
+                                    title = f"TodoUpdate: {subject}"
+                            elif event.tool_name in ("TodoGet", "TodoStop", "TodoOutput"):
                                 tid = str(event.tool_args.get("taskId", event.tool_args.get("task_id", "")))
                                 if tid:
                                     title = f"{event.tool_name}: {tid}"
-                            elif event.tool_name == "TodoCreate":
-                                text = str(event.tool_args.get("text", ""))
-                                if text:
-                                    title = f"TodoCreate: {text[:40]}"
                             elif event.tool_name == "Glob":
                                 pattern = str(event.tool_args.get("pattern", ""))
                                 if pattern:
@@ -1520,10 +1613,22 @@ class CDHACPAdapter:
                             "_tool_name": event.tool_name,
                             "_tool_args": event.tool_args,
                         })
-                        self.send_session_update(self.tool_calls[event.tool_id])
+                        # Skip sending tool_call_update for Spawn — SubAgent widget
+                        # handles the display via subagent_start/chunk/end events.
+                        if event.tool_name != "Spawn":
+                            self.send_session_update(self.tool_calls[event.tool_id])
                 elif event.type == StreamEventType.TOOL_RESULT:
-                    status = "failed" if event.result_is_error else "completed"
+                    # Spawn tool results: subagent_start/chunk/end events were
+                    # already sent during subagent execution — just skip the
+                    # tool_call_update (no duplicate SubAgent widget needed).
                     tname = self.tool_calls.get(event.tool_id, {}).get("_tool_name", "")
+                    if tname == "Spawn":
+                        try:
+                            self.agent.save_session()
+                        except Exception:
+                            debug_log("Failed to save session after subagent", exc_info=True)
+                        continue
+                    status = "failed" if event.result_is_error else "completed"
                     display_text = _format_tui_display_text(
                         event.result_content or "", tname,
                     )
@@ -1539,7 +1644,7 @@ class CDHACPAdapter:
                                 current_title = self.tool_calls[event.tool_id].get("title", "")
                                 if ":" not in current_title:
                                     tname = self.tool_calls[event.tool_id].get("_tool_name", "")
-                                    if tname in ("TaskCreate", "TaskUpdate"):
+                                    if tname in ("TodoCreate", "TodoUpdate"):
                                         task_info = parsed.get("task", {})
                                         if isinstance(task_info, dict):
                                             if subject := task_info.get("subject", ""):
@@ -1578,9 +1683,8 @@ class CDHACPAdapter:
                         "type": "content",
                         "content": {"type": "text", "text": display_text},
                     }] if display_text else []
-                    if event.tool_id in self.tool_calls:
-                        existing_content = self.tool_calls[event.tool_id].get("content", [])
-                    else:
+                    existing_content = self.tool_calls.get(event.tool_id, {}).get("content", [])
+                    if not isinstance(existing_content, list):
                         existing_content = []
                     debug_log(
                         "TOOL_RESULT id=%s status=%s result_len=%d display_len=%d existing_blocks=%d new_blocks=%d",
@@ -1629,6 +1733,7 @@ class CDHACPAdapter:
                         "sessionUpdate": "subagent_start",
                         "subagentId": event.subagent_id,
                         "agentType": event.subagent_type,
+                        "prompt": event.subagent_prompt,
                     })
                 elif event.type == StreamEventType.SUBAGENT_CHUNK:
                     self.send_session_update({
@@ -1636,11 +1741,19 @@ class CDHACPAdapter:
                         "subagentId": event.subagent_id,
                         "text": event.subagent_text,
                     })
+                elif event.type == StreamEventType.SUBAGENT_THINKING:
+                    self.send_session_update({
+                        "sessionUpdate": "subagent_thinking",
+                        "subagentId": event.subagent_id,
+                        "text": event.subagent_thinking_text,
+                    })
                 elif event.type == StreamEventType.SUBAGENT_END:
                     self.send_session_update({
                         "sessionUpdate": "subagent_end",
                         "subagentId": event.subagent_id,
                         "agentType": event.subagent_type,
+                        "status": event.subagent_status,
+                        "error": event.subagent_error,
                     })
                 elif event.type == StreamEventType.PLAN:
                     self.send_session_update({
@@ -1846,6 +1959,7 @@ class CDHACPAdapter:
         except Exception:
             import traceback
             tb = traceback.format_exc()
+            _dump_crash("chat_stream")
             debug_log("Unhandled exception in chat_stream:\n%s", tb, exc_info=True)
             print(f"[cdh-agent-acp] ERROR in chat_stream:\n{tb}", file=sys.stderr, flush=True)
             self._text_chunker.flush()
@@ -1859,7 +1973,7 @@ class CDHACPAdapter:
             except Exception:
                 pass
             try:
-                self.agent.save_tasks_to_project()
+                self.agent.save_todos_to_project()
             except Exception:
                 pass
             return {"stopReason": "error", "message": "Internal agent error"}
@@ -1874,7 +1988,7 @@ class CDHACPAdapter:
 
         # Persist tasks to project .cdh/ so they survive Ctrl+C
         try:
-            self.agent.save_tasks_to_project()
+            self.agent.save_todos_to_project()
         except Exception:
             debug_log("Failed to save tasks to .cdh at turn end", exc_info=True)
 
@@ -1888,21 +2002,8 @@ class CDHACPAdapter:
             "size": size,
         })
 
-        # Send final action summary if tool calls were made this turn
-        if self.tool_calls:
-            summaries: list[str] = []
-            for tid, tc in self.tool_calls.items():
-                action = tc.get("title", "")
-                status = tc.get("status", "")
-                if action:
-                    emoji = "✅" if status == "completed" else "❌" if status == "failed" else "⏳"
-                    summaries.append(f"{emoji} {action}")
-            if summaries:
-                summary_text = "\n".join(summaries)
-                self.send_session_update({
-                    "sessionUpdate": "agent_message_chunk",
-                    "content": {"type": "text", "text": f"```output\n{summary_text}\n```"},
-                })
+        # Tool call summary suppressed — internal step tracking
+        # is not shown to avoid cluttering conversation output.
 
         stop_reason = "cancelled" if self.agent._cancelled else "end_turn"
         usage = self._build_session_usage()
@@ -1966,6 +2067,15 @@ class CDHACPAdapter:
             "output_tokens": total_out,
         }
 
+    async def session_save(self, session_id: str, _meta: dict):
+        """Save current session state."""
+        if self.agent:
+            try:
+                self.agent.save_session()
+            except Exception:
+                debug_log("Failed to save session on save", exc_info=True)
+        return {}
+
     async def session_cancel(self, session_id: str, _meta: dict):
         """Cancel current session."""
         if self.agent:
@@ -1976,7 +2086,7 @@ class CDHACPAdapter:
                 debug_log("Failed to save session on cancel", exc_info=True)
             # Persist tasks to .cdh so they survive Ctrl+C and re-entry
             try:
-                self.agent.save_tasks_to_project()
+                self.agent.save_todos_to_project()
             except Exception:
                 debug_log("Failed to save tasks to .cdh on cancel", exc_info=True)
         return {}
@@ -2022,6 +2132,7 @@ class JSONRPCServer:
             "session/load": self._handle_session_load,
             "session/prompt": self._handle_session_prompt,
             "session/cancel": self._handle_session_cancel,
+            "session/save": self._handle_session_save,
             "session/set_mode": self._handle_session_set_mode,
             "session/ask_user_answer": self._handle_ask_user_answer,
             "terminal/create": self._handle_terminal_create,
@@ -2067,6 +2178,12 @@ class JSONRPCServer:
             params.get("sessionId"),
         )
 
+    async def _handle_session_save(self, params: dict):
+        return await self.adapter.session_save(
+            params.get("sessionId"),
+            params.get("_meta", {}),
+        )
+
     async def _handle_session_prompt(self, params: dict):
         return await self.adapter.session_prompt(
             params.get("prompt", []),
@@ -2139,6 +2256,7 @@ async def _main():
         except Exception as e:
             import traceback
             tb = traceback.format_exc()
+            _dump_crash("_run_prompt")
             print(f"[cdh-agent-acp] ERROR in _run_prompt:\n{tb}", file=sys.stderr, flush=True)
             debug_log("_run_prompt failed: %s\n%s", e, tb, exc_info=True)
             return {"jsonrpc": "2.0", "error": {"code": -32603, "message": str(e)}, "id": req.get("id")}
@@ -2181,10 +2299,15 @@ async def _main():
                     try:
                         resp = t.result()
                     except Exception as exc:
+                        _dump_crash("_on_prompt_done")
                         debug_log(f"Prompt task raised unhandled exception: {exc}", exc_info=True)
                         resp = {"jsonrpc": "2.0", "error": {"code": -32603, "message": str(exc)}, "id": req.get("id")}
                     if resp.get("id") is not None:
-                        print(json.dumps(resp), flush=True)
+                        try:
+                            print(json.dumps(resp), flush=True)
+                        except (TypeError, ValueError, OSError) as e:
+                            _dump_crash("_on_prompt_done_send")
+                            debug_log("_on_prompt_done send failed: %s", e)
                 prompt_task.add_done_callback(_on_prompt_done)
             elif method == "session/cancel":
                 if prompt_task and not prompt_task.done():
@@ -2193,7 +2316,11 @@ async def _main():
             else:
                 response = await server.handle_request(req)
                 if response.get("id") is not None:
-                    print(json.dumps(response), flush=True)
+                    try:
+                        print(json.dumps(response), flush=True)
+                    except (TypeError, ValueError, OSError) as e:
+                        _dump_crash("main_loop_send")
+                        debug_log("main loop send failed: %s", e)
 
 
 def main():

package/onecode/agent/session.py

@@ -23,7 +23,6 @@ class SessionData:
     lifecycle_state: dict = field(default_factory=dict)
     created_at: Optional[str] = None
     updated_at: Optional[str] = None
-    tasks: list[dict] = field(default_factory=list)
     todos: list[dict] = field(default_factory=list)
 
     def to_dict(self) -> dict:
@@ -38,12 +37,18 @@ class SessionData:
             "lifecycle_state": self.lifecycle_state,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
-            "tasks": self.tasks,
             "todos": self.todos,
         }
 
     @classmethod
     def from_dict(cls, data: dict) -> SessionData:
+        # Merge legacy ``tasks`` and ``todos`` fields into the unified
+        # ``todos`` list.  Older sessions stored them as two separate lists;
+        # TodoManager.from_dict already handles the legacy entry shape, so
+        # we just concatenate here.
+        legacy_todos: list[dict] = []
+        legacy_todos.extend(data.get("tasks") or [])
+        legacy_todos.extend(data.get("todos") or [])
         return cls(
             id=data.get("id", str(uuid.uuid4())),
             name=data.get("name", "Untitled"),
@@ -55,8 +60,7 @@ class SessionData:
             lifecycle_state=data.get("lifecycle_state", {}),
             created_at=data.get("created_at"),
             updated_at=data.get("updated_at"),
-            tasks=data.get("tasks", []),
-            todos=data.get("todos", []),
+            todos=legacy_todos,
         )
 
 
@@ -66,7 +70,6 @@ class AgentSession:
         self._data: SessionData = SessionData()
         if session_id:
             self._data.id = session_id
-            self.load()
 
     def _default_storage_path(self) -> Path:
         from onecode.config import CLOUD_DEV_HARNESS_DIR
@@ -96,14 +99,6 @@ class AgentSession:
     def lifecycle_state(self) -> dict:
         return self._data.lifecycle_state
 
-    @property
-    def tasks(self) -> list[dict]:
-        return self._data.tasks
-
-    @tasks.setter
-    def tasks(self, value: list[dict]) -> None:
-        self._data.tasks = value
-
     @property
     def todos(self) -> list[dict]:
         return self._data.todos

package/onecode/agent/tools/agent_tools.py

@@ -87,7 +87,7 @@ class TaskTool:
 
     def spec(self) -> ToolSpec:
         return ToolSpec(
-            name="Task",
+            name="Spawn",
             description="Delegate a subtask to a specialized subagent. Use for large, independent, or specialized work that benefits from a focused sub-agent.",
             input_schema={
                 "type": "object",
@@ -108,7 +108,7 @@ class TaskTool:
         prompt = tool_input.get("prompt", "")
         if agent_type not in self.VALID_AGENT_TYPES:
             return ToolResult(
-                name="Task",
+                name="Spawn",
                 output={
                     "error": (
                         f"Unknown agent_type '{agent_type}'. "
@@ -129,6 +129,6 @@ class TaskTool:
             else:
                 result = asyncio.run(self._spawn(agent_type, prompt))
         except Exception as e:
-            return ToolResult(name="Task", output={"error": str(e)}, is_error=True)
-        return ToolResult(name="Task", output=str(result))
+            return ToolResult(name="Spawn", output={"error": str(e)}, is_error=True)
+        return ToolResult(name="Spawn", output=str(result))