@scemoon/cdh 1.0.4 → 1.0.6

package/onecode/agent/onecode_agent_acp.py

@@ -43,16 +43,31 @@ def debug_log(*args, **kwargs):
         print("[onecode]", *args, file=sys.stderr, flush=True)
 
 
-_CRASH_LOG_DIR = Path.home() / ".cdh" / "logs"
+def info_log(*args, **kwargs):
+    """INFO-level lifecycle log so critical events survive even default log_level=info.
+
+    ``debug_log`` is filtered out at INFO; previously all ACP/subagent
+    diagnostic markers were DEBUG, so users running with the default
+    ``log_level: info`` saw an empty log and could not diagnose the
+    subagent hang.  Use ``info_log`` for critical lifecycle boundaries
+    (adapter init, cancel, subagent dispatch markers).
+    """
+    if logger.handlers or logging.getLogger().handlers:
+        logger.info(" ".join(str(a) for a in args), **kwargs)
+    else:
+        print("[onecode]", *args, file=sys.stderr, flush=True)
+
+
+_CRASH_LOG_DIR = Path.home() / ".onecode" / "logs"
 
 
 def _dump_crash(context: str) -> None:
-    """Write traceback to ``~/.cdh/logs/cdh_crash.log`` so it survives subprocess exit."""
+    """Write traceback to ``~/.onecode/logs/onecode_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"
+    path = _CRASH_LOG_DIR / "onecode_crash.log"
     try:
         lines = [f"=== crash at {now} context={context} ===\n"]
         for tb_line in traceback.format_exc().splitlines(True):
@@ -73,7 +88,6 @@ from onecode.models.registry import ModelRegistry
 from onecode.models.messages import (
     StreamEventType,
     ToolCategory,
-    AgentMessage,
     TextBlock,
     ThinkBlock,
     ToolCall as MsgToolCall,
@@ -82,14 +96,8 @@ from onecode.models.messages import (
     LifecycleStatus,
     get_tool_category,
 )
+import onecode.models.providers  # noqa: F401  trigger ProviderRegistry.register()
 
-from onecode.models.providers.minimaxi_provider import MiniMaxiProvider
-from onecode.models.providers.minimax_provider import MiniMaxProvider
-from onecode.models.providers.anthropic_provider import AnthropicProvider
-from onecode.models.providers.openai_provider import OpenAIProvider
-from onecode.models.providers.deepseek_provider import DeepSeekProvider
-from onecode.models.providers.glm_provider import GLMProvider
-from onecode.models.providers.ollama_provider import OllamaProvider
 
 
 _CATEGORY_TO_ACP_KIND: dict[str, str] = {
@@ -325,8 +333,8 @@ def _build_tool_call_content(name: str | None, arguments: dict) -> list:
     (Markdown / Static). JSON-fence fallbacks only kick in for tools we
     don't recognise, so known tools render as their intended visual.
 
-    Write emits a Markdown block (`path` header + code fence) so the
-    content reads as code rather than a noisy all-additions diff.
+    Write emits a code fence so the content reads as proper code
+    rather than a noisy all-additions diff view.
     Edit keeps the diff block because there are real before/after changes.
     """
     if not arguments:
@@ -336,8 +344,8 @@ def _build_tool_call_content(name: str | None, arguments: dict) -> list:
         return []
 
     _HEADER_ONLY_TOOLS = frozenset({
-        "TodoCreate", "TodoGet", "TodoList", "TodoUpdate", "TodoOutput", "TodoStop",
-        "Glob", "Spawn",
+        "TodoCreate", "TodoGet", "TodoList", "TodoUpdate", "TodoOutput", "TodoStop", "TodoClear",
+        "Glob", "List", "Spawn",
     })
     if name in _HEADER_ONLY_TOOLS:
         return []
@@ -351,7 +359,7 @@ def _build_tool_call_content(name: str | None, arguments: dict) -> list:
                 "type": "content",
                 "content": {
                     "type": "text",
-                    "text": f"📄 {path}\n```{lang}\n{content}\n```",
+                    "text": f"```{lang}\n{content}\n```",
                 },
             }]
 
@@ -378,6 +386,21 @@ def _build_tool_call_content(name: str | None, arguments: dict) -> list:
                 },
             }]
 
+    if name == "Grep":
+        pattern = str(arguments.get("pattern", ""))
+        include = arguments.get("include")
+        if pattern:
+            text = f"🔍 Pattern: `{pattern}`"
+            if include:
+                text += f"\n📁 Filter: `{include}`"
+            return [{
+                "type": "content",
+                "content": {"type": "text", "text": text},
+            }]
+
+    if name == "ToolSearch":
+        return []
+
     if name == "ApplyPatch":
         patch = str(arguments.get("patch", ""))
         if patch:
@@ -424,11 +447,7 @@ def _build_tool_call_content(name: str | None, arguments: dict) -> list:
             "content": {"type": "text", "text": "\n".join(lines)},
         }] if lines else []
 
-    args_text = json.dumps(arguments, indent=2, ensure_ascii=False)
-    return [{
-        "type": "content",
-        "content": {"type": "text", "text": f"```json\n{args_text}\n```"},
-    }]
+    return []
 
 
 def _format_tui_display_text(result_text: str, tool_name: str = "") -> str:
@@ -456,6 +475,19 @@ def _format_tui_display_text(result_text: str, tool_name: str = "") -> str:
         return result_text
     if not isinstance(parsed, dict):
         return result_text
+    if tool_name == "ToolSearch":
+        matches = parsed.get("matches", [])
+        if matches:
+            lines = [f"🔍 Found {len(matches)} tool(s):", ""]
+            for m in matches:
+                name = m.get("name", "")
+                desc = m.get("description", "")
+                if desc:
+                    lines.append(f"  • **{name}** — {desc}")
+                else:
+                    lines.append(f"  • **{name}**")
+            return "\n".join(lines)
+        return "No matching tools found."
     if "error" in parsed:
         return str(parsed["error"])
     # Read: show actual file content (code fence + language wrapping in _emit_tool_result)
@@ -464,10 +496,12 @@ def _format_tui_display_text(result_text: str, tool_name: str = "") -> str:
     # Todo tools: collapse verbose state echoes to one-liner.
     if tool_name in _STATUS_ONLY_TOOLS:
         return "✓ updated"
+    if tool_name == "Write":
+        return ""
     if parsed.get("success") is True:
         if path := parsed.get("path"):
             return f"✓ {path}"
-        visible = {k: v for k, v in parsed.items() if k != "success"}
+        visible = {k: v for k, v in parsed.items() if k != "success" and v not in ("", None)}
         if not visible:
             return "✓ done"
         try:
@@ -484,6 +518,7 @@ _STATUS_ONLY_TOOLS = frozenset({
     "TodoUpdate",
     "TodoOutput",
     "TodoStop",
+    "TodoClear",
 })
 
 
@@ -661,6 +696,14 @@ class CDHACPAdapter:
         self._request_seq = 0
         self._perm_store = PermissionStore()
         self._ask_user_future: asyncio.Future[dict] | None = None
+        # Diagnostics: per-subagent ACP forward counters (id → int)
+        self._subagent_fwd_count: dict[str, int] = {}
+        self._subagent_fwd_bytes: dict[str, int] = {}
+        # Display state for tools invoked *inside* a subagent, keyed by a
+        # namespaced id ``"sa:{subagent_id}:{inner_tool_id}"`` (kept separate
+        # from ``self.tool_calls`` so subagent tool cards never collide with
+        # main-agent tool ids nor get persisted into the main session view).
+        self._subagent_tool_calls: dict[str, dict] = {}
 
     def _perm_store_load(self, cwd: str | None = None) -> None:
         """Load permission overrides from ``.cdh/permissions.json``."""
@@ -837,9 +880,23 @@ class CDHACPAdapter:
     def cancel_prompt(self):
         """Synchronously cancel the current prompt (called from main loop)."""
         if self.agent:
+            n_children = len(self.agent._child_engines)
+            child_ids = [hex(id(c)) for c in self.agent._child_engines]
+            info_log(
+                "[ACP-CANCEL] cancel_prompt called; marking agent._cancelled=True; "
+                "children=%d ids=%s already_cancelled=%s",
+                n_children, child_ids, self.agent._cancelled,
+            )
             self.agent._cancelled = True
             for child in self.agent._child_engines:
                 child._cancelled = True
+            info_log(
+                "[ACP-CANCEL] after mark: agent._cancelled=%s subagent_fwd=%s",
+                self.agent._cancelled,
+                dict(self._subagent_fwd_count),
+            )
+        else:
+            info_log("[ACP-CANCEL] cancel_prompt called but self.agent is None")
 
     def resolve_ask_user(self, answer: str, cancelled: bool) -> dict:
         """Resolve the pending ask_user request with the user's answer.
@@ -857,6 +914,156 @@ class CDHACPAdapter:
             "update": update,
         })
 
+    def _subagent_tool_ns_id(self, subagent_id: str, inner_tool_id: str) -> str:
+        """Namespaced toolCallId so subagent tool cards never collide with
+        main-agent tool ids in the TUI or in ``self.tool_calls``."""
+        return f"sa:{subagent_id}:{inner_tool_id}"
+
+    def _handle_subagent_tool_call(self, event) -> None:
+        """Render a tool invoked *inside* a subagent as a real tool_call /
+        tool_call_update sessionUpdate tagged with ``subagentId`` so the TUI
+        mounts a ToolCall card inside the owning SubAgent widget (same style
+        as main-conversation tools) instead of a ``[Tool: X]`` text line."""
+        sa_id = event.subagent_id
+        ns_id = self._subagent_tool_ns_id(sa_id, event.tool_id)
+        tname = event.tool_name or "Tool"
+        if tname == "Spawn":
+            # Nested spawn is disallowed (depth limit); skip rendering.
+            return
+        tool_kind = _kind_for_category(event.tool_category)
+
+        if event.subagent_tool_phase != "complete":
+            # start: in_progress card with the tool name as title.
+            entry = self._subagent_tool_calls.get(ns_id)
+            if entry is None:
+                entry = {
+                    "sessionUpdate": "tool_call",
+                    "toolCallId": ns_id,
+                    "subagentId": sa_id,
+                    "title": tname,
+                    "kind": tool_kind,
+                    "status": "in_progress",
+                    "content": [],
+                    "_tool_name": tname,
+                    "_tool_args": {},
+                }
+                self._subagent_tool_calls[ns_id] = entry
+            else:
+                entry["subagentId"] = sa_id
+                entry["kind"] = tool_kind
+                entry["status"] = "in_progress"
+                entry["_tool_name"] = tname
+            self.send_session_update(entry)
+            return
+
+        # complete: enrich title from args + attach args content.
+        args = event.tool_args or {}
+        title = tname
+        if args:
+            if args.get("path", ""):
+                title = f"{tname}: {_short_path(args.get('path', ''), self.agent._project_dir)}"
+            elif tname == "Bash":
+                cmd = str(args.get("command", ""))
+                if cmd:
+                    title = f"Bash: {cmd}"
+            elif tname in ("TodoCreate", "TodoUpdate"):
+                subject = str(args.get("subject", ""))
+                if subject:
+                    title = f"{tname}: {subject}"
+            elif tname in ("TodoGet", "TodoStop", "TodoOutput"):
+                tid = str(args.get("taskId", args.get("task_id", "")))
+                if tid:
+                    title = f"{tname}: {tid}"
+            elif tname == "Glob":
+                pattern = str(args.get("pattern", ""))
+                if pattern:
+                    title = f"Glob: {pattern}"
+            elif tname == "ToolSearch":
+                query = str(args.get("query", ""))
+                if query:
+                    title = f"ToolSearch: {query}"
+            else:
+                for key in ("query", "command", "pattern", "name", "subject"):
+                    val = str(args.get(key, ""))
+                    if val:
+                        title = f"{tname}: {val}"
+                        break
+        content = _build_tool_call_content(tname, args)
+        entry = self._subagent_tool_calls.get(ns_id)
+        if entry is None:
+            entry = {
+                "sessionUpdate": "tool_call",
+                "toolCallId": ns_id,
+                "subagentId": sa_id,
+                "title": tname,
+                "kind": tool_kind,
+                "status": "in_progress",
+                "content": [],
+                "_tool_name": tname,
+                "_tool_args": {},
+            }
+            self._subagent_tool_calls[ns_id] = entry
+        entry.update({
+            "sessionUpdate": "tool_call_update",
+            "toolCallId": ns_id,
+            "subagentId": sa_id,
+            "title": title,
+            "status": "in_progress",
+            "content": content,
+            "_tool_name": tname,
+            "_tool_args": args,
+        })
+        self.send_session_update(entry)
+
+    def _handle_subagent_tool_result(self, event) -> None:
+        """Attach a subagent tool's result to its card (completed/failed)."""
+        sa_id = event.subagent_id
+        ns_id = self._subagent_tool_ns_id(sa_id, event.tool_id)
+        entry = self._subagent_tool_calls.get(ns_id)
+        tname = (entry or {}).get("_tool_name", "") or event.tool_name or "Tool"
+        targs = (entry or {}).get("_tool_args", {}) or {}
+        if tname == "Spawn":
+            return
+        status = "failed" if event.result_is_error else "completed"
+        display_text = _format_tui_display_text(event.result_content or "", tname)
+        # Fence multi-line results so the TUI renders a code block (mirrors
+        # the main TOOL_RESULT handler).
+        if display_text and "\n" in display_text and "```" not in display_text:
+            lang = ""
+            if tname in ("Bash", "Glob"):
+                lang = "bash"
+            elif tname == "Read" and isinstance(targs, dict):
+                path = str(targs.get("path", ""))
+                if path:
+                    lang = _language_for_path(path)
+            display_text = f"```{lang}\n{display_text}\n```" if lang else f"```\n{display_text}\n```"
+        content_block = [{
+            "type": "content",
+            "content": {"type": "text", "text": display_text},
+        }] if display_text else []
+        existing_content = (entry or {}).get("content", [])
+        if not isinstance(existing_content, list):
+            existing_content = []
+        if entry is None:
+            entry = {
+                "sessionUpdate": "tool_call_update",
+                "toolCallId": ns_id,
+                "subagentId": sa_id,
+                "title": tname,
+                "kind": _kind_for_category(get_tool_category(tname)),
+                "status": status,
+                "content": existing_content + content_block,
+                "_tool_name": tname,
+                "_tool_args": targs,
+            }
+            self._subagent_tool_calls[ns_id] = entry
+        else:
+            entry["subagentId"] = sa_id
+            entry["status"] = status
+            entry["content"] = existing_content + content_block
+            entry["sessionUpdate"] = "tool_call_update"
+        self.send_session_update(entry)
+
     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
@@ -870,6 +1077,11 @@ class CDHACPAdapter:
             tool_name = tool_name.split(":", 1)[0].strip()
         display_text = _format_tui_display_text(block.content, tool_name)
 
+        # For edit/write tools the diff/code block + header ✔ status is
+        # sufficient — skip the redundant "✓ /path" result text.
+        if display_text and self.tool_calls.get(block.tool_use_id, {}).get("kind") == "edit":
+            display_text = ""
+
         # Update title with path/subject from result if not already set
         if block.content and block.tool_use_id in self.tool_calls:
             try:
@@ -1015,6 +1227,8 @@ class CDHACPAdapter:
 
     async def session_new(self, cwd: str, mcp_servers: list):
         """Create new session."""
+        if self.agent is not None:
+            await self.agent.shutdown()
         cfg = load_config()
         self.agent = _create_engine(cwd, perm_store=self._perm_store)
         self.agent.set_agent(cfg.default_mode)
@@ -1031,9 +1245,14 @@ class CDHACPAdapter:
         self.agent.attach_session(session)
         self.session_id = session.id
 
-        # Restore tasks from project .cdh/ if available
-        self.agent.load_todos_from_project()
-
+        # New sessions start with a blank plan — inject a hint so the user
+        # knows previous session todos are not restored.
+        self.agent.context.add_system(
+            "<!-- NEW_SESSION_HINT -->\n"
+            "This is a new session with a blank plan. Previous session todos "
+            "are not automatically restored. Use `/resume <session_id>` to "
+            "recover a previous session's plan if needed.\n"
+        )
         self._send_available_commands()
 
         return {
@@ -1046,6 +1265,8 @@ class CDHACPAdapter:
 
     async def session_load(self, cwd: str, mcp_servers: list, session_id: str):
         """Load existing session."""
+        if self.agent is not None:
+            await self.agent.shutdown()
         self._perm_store_load(cwd)
         self.agent = _create_engine(cwd, perm_store=self._perm_store)
         self.session_id = session_id
@@ -1064,13 +1285,44 @@ class CDHACPAdapter:
         self._emit_plan_update_to_tui()
 
         if not loaded:
-            return {"modes": _DEFAULT_MODES}
+            return {
+                "modes": _DEFAULT_MODES,
+                "error": f"Session {session_id} not found at {self.agent._session.storage_path}",
+            }
 
         # Walk the in-memory context (preserves list-of-blocks structure)
         # instead of the raw _session.messages dicts, which only carry
         # `content: str`.  Engine.chat_stream() stores tool_use / tool_result
         # blocks in context.Message.content, and we need them at replay time.
-        for ctx_msg in self.agent.context.messages:
+        # Only replay the most recent MAX_VISIBLE messages; older ones are
+        # fetched on demand via session/load_earlier.
+        MAX_VISIBLE = 50
+        total_messages = len(self.agent.context.messages)
+        visible_start = max(0, total_messages - MAX_VISIBLE)
+        self._replay_messages(self.agent.context.messages[visible_start:])
+
+        return {
+            "modes": {
+                "currentModeId": cfg.default_mode,
+                "availableModes": _DEFAULT_MODES["availableModes"],
+            },
+            "_total_messages": total_messages,
+            "_visible_start": visible_start,
+        }
+
+    async def session_load_earlier(self, session_id: str, offset: int, limit: int) -> dict:
+        """Replay a range of earlier messages (used by 'load earlier messages')."""
+        if self.agent is None or self.agent.context is None:
+            return {"count": 0, "remaining": 0}
+        messages = self.agent.context.messages
+        end = min(offset + limit, len(messages))
+        segment = messages[offset:end]
+        self._replay_messages(segment)
+        return {"count": end - offset, "remaining": offset}
+
+    def _replay_messages(self, messages: list) -> None:
+        """Replay a list of context messages as session/update notifications."""
+        for ctx_msg in messages:
             role = ctx_msg.role
             content = ctx_msg.content
             if role == "user":
@@ -1146,10 +1398,6 @@ class CDHACPAdapter:
                     elif isinstance(block, ToolResult):
                         self._emit_tool_result(block)
                     elif isinstance(block, SubAgentBlock):
-                        content_block = [{
-                            "type": "content",
-                            "content": {"type": "text", "text": block.result},
-                        }] if block.result else []
                         self.send_session_update({
                             "sessionUpdate": "subagent_start",
                             "subagentId": block.id,
@@ -1183,13 +1431,6 @@ class CDHACPAdapter:
                         content.get("is_error", False),
                     )
 
-        return {
-            "modes": {
-                "currentModeId": cfg.default_mode,
-                "availableModes": _DEFAULT_MODES["availableModes"],
-            },
-        }
-
     def _make_stream_callback(self):
         """Create a thinking-aware streaming callback for real-time token output.
 
@@ -1484,6 +1725,13 @@ class CDHACPAdapter:
         # Fresh per-turn tracking (tool_calls accumulates across one turn only)
         self.tool_calls = {}
         self.agent._cancelled = False
+        self._subagent_fwd_count = {}
+        self._subagent_fwd_bytes = {}
+        self._subagent_tool_calls = {}
+        info_log(
+            "[ACP-PROMPT] entering chat_stream loop; agent._cancelled reset to "
+            "False; session=%s", session_id,
+        )
 
         # Create chunkers for agent_message_chunk and agent_thought_chunk
         self._text_chunker = TextChunker(
@@ -1589,6 +1837,20 @@ class CDHACPAdapter:
                                 pattern = str(event.tool_args.get("pattern", ""))
                                 if pattern:
                                     title = f"Glob: {pattern}"
+                            elif event.tool_name == "Grep":
+                                pattern = str(event.tool_args.get("pattern", ""))
+                                if pattern:
+                                    title = f"Grep: {pattern}"
+                            elif event.tool_name == "ToolSearch":
+                                query = str(event.tool_args.get("query", ""))
+                                if query:
+                                    title = f"ToolSearch: {query}"
+                            else:
+                                for key in ("query", "command", "pattern", "name", "subject"):
+                                    val = str(event.tool_args.get(key, ""))
+                                    if val:
+                                        title = f"{event.tool_name}: {val}"
+                                        break
                             content = _build_tool_call_content(
                                 event.tool_name, event.tool_args
                             )
@@ -1633,6 +1895,11 @@ class CDHACPAdapter:
                         event.result_content or "", tname,
                     )
 
+                    # For edit/write tools the diff/code block + header ✔ status is
+                    # sufficient — skip the redundant "✓ /path" result text.
+                    if display_text and self.tool_calls.get(event.tool_id, {}).get("kind") == "edit":
+                        display_text = ""
+
                     # Update title with path/subject from result if not already set
                     if event.result_content and event.tool_id in self.tool_calls:
                         try:
@@ -1662,14 +1929,14 @@ class CDHACPAdapter:
                     # Wrap multi-line results in a fenced code block so they
                     # display as a code block rather than a raw paragraph.
                     # For Read results, detect language from the file path.
-                    # For Bash/Glob, use bash-style fence.
+                    # For Bash/Glob/Grep/List, use bash-style fence.
                     # Skip if already contains a code fence to avoid nesting.
-                    if display_text and "\n" in display_text and "```" not in display_text:
+                    if display_text and "\n" in display_text and "```" not in display_text and tname != "ToolSearch":
                         lang = ""
                         tool_info = self.tool_calls.get(event.tool_id, {})
                         tname = tool_info.get("_tool_name", "")
                         targs = tool_info.get("_tool_args", {})
-                        if tname in ("Bash", "Glob"):
+                        if tname in ("Bash", "Glob", "Grep", "List"):
                             lang = "bash"
                         elif tname == "Read" and isinstance(targs, dict):
                             path = str(targs.get("path", ""))
@@ -1729,25 +1996,66 @@ class CDHACPAdapter:
                 elif event.type == StreamEventType.SUBAGENT_START:
                     self._text_chunker.flush()
                     self._thought_chunker.flush()
+                    info_log(
+                        "[ACP-SUBagent] SUBAGENT_START id=%s type=%s prompt_len=%d",
+                        event.subagent_id, event.subagent_type,
+                        len(event.subagent_prompt or ""),
+                    )
                     self.send_session_update({
                         "sessionUpdate": "subagent_start",
                         "subagentId": event.subagent_id,
                         "agentType": event.subagent_type,
                         "prompt": event.subagent_prompt,
                     })
+                    self._subagent_fwd_count[event.subagent_id] = 0
+                    self._subagent_fwd_bytes[event.subagent_id] = 0
                 elif event.type == StreamEventType.SUBAGENT_CHUNK:
+                    _cnt = self._subagent_fwd_count.get(event.subagent_id, 0) + 1
+                    self._subagent_fwd_count[event.subagent_id] = _cnt
+                    _by = self._subagent_fwd_bytes.get(event.subagent_id, 0) + len(event.subagent_text or "")
+                    self._subagent_fwd_bytes[event.subagent_id] = _by
+                    if _cnt <= 5 or _cnt % 50 == 0:
+                        debug_log(
+                            "[ACP-SUBagent] SUBAGENT_CHUNK id=%s chunk#%d bytes=%d total=%d",
+                            event.subagent_id, _cnt, len(event.subagent_text or ""),
+                            _by,
+                        )
                     self.send_session_update({
                         "sessionUpdate": "subagent_chunk",
                         "subagentId": event.subagent_id,
                         "text": event.subagent_text,
                     })
                 elif event.type == StreamEventType.SUBAGENT_THINKING:
+                    debug_log(
+                        "[ACP-SUBagent] SUBAGENT_THINKING id=%s bytes=%d",
+                        event.subagent_id, len(event.subagent_thinking_text or ""),
+                    )
                     self.send_session_update({
                         "sessionUpdate": "subagent_thinking",
                         "subagentId": event.subagent_id,
                         "text": event.subagent_thinking_text,
                     })
                 elif event.type == StreamEventType.SUBAGENT_END:
+                    chunk_count = self._subagent_fwd_count.pop(event.subagent_id, None)
+                    self._subagent_fwd_bytes.pop(event.subagent_id, None)
+                    info_log(
+                        "[ACP-SUBagent] SUBAGENT_END id=%s type=%s status=%s "
+                        "err=%r chunk_count=%s",
+                        event.subagent_id, event.subagent_type,
+                        event.subagent_status, (event.subagent_error or "")[:100],
+                        chunk_count,
+                    )
+                    # If there's no active subagent for this id, the engine
+                    # rejected a nested Spawn (depth exceeded). Drop the
+                    # orphan end event so the TUI doesn't get a stale
+                    # subagent_end without a matching subagent_start.
+                    if chunk_count is None:
+                        debug_log(
+                            "[ACP-SUBagent] DROP orphan SUBAGENT_END id=%s "
+                            "(no matching start — likely nested Spawn rejection)",
+                            event.subagent_id,
+                        )
+                        continue
                     self.send_session_update({
                         "sessionUpdate": "subagent_end",
                         "subagentId": event.subagent_id,
@@ -1755,6 +2063,10 @@ class CDHACPAdapter:
                         "status": event.subagent_status,
                         "error": event.subagent_error,
                     })
+                elif event.type == StreamEventType.SUBAGENT_TOOL_CALL:
+                    self._handle_subagent_tool_call(event)
+                elif event.type == StreamEventType.SUBAGENT_TOOL_RESULT:
+                    self._handle_subagent_tool_result(event)
                 elif event.type == StreamEventType.PLAN:
                     self.send_session_update({
                         "sessionUpdate": "plan",
@@ -1947,6 +2259,8 @@ class CDHACPAdapter:
                               "content": result_str, "is_error": is_error}],
                             name=tid,
                         )
+                        # Sync plan after approval — the tool may have mutated todos
+                        self._emit_plan_update_to_tui()
                     verb = "Approved" if approved else "Rejected"
                     self.send_session_update({
                         "sessionUpdate": "agent_message_chunk",
@@ -1966,7 +2280,7 @@ class CDHACPAdapter:
             self._thought_chunker.flush()
             self.send_session_update({
                 "sessionUpdate": "agent_message_chunk",
-                "content": {"type": "text", "text": f"Error: internal error"},
+                "content": {"type": "text", "text": "Error: internal error"},
             })
             try:
                 self.agent.save_session()
@@ -1992,6 +2306,9 @@ class CDHACPAdapter:
         except Exception:
             debug_log("Failed to save tasks to .cdh at turn end", exc_info=True)
 
+        # Sync plan to TUI so sidebar shows final todo state
+        self._emit_plan_update_to_tui()
+
         # Send context usage stats to TUI sidebar
         ctx = self.agent.context
         used = ctx._token_count if ctx else 0
@@ -2080,6 +2397,7 @@ class CDHACPAdapter:
         """Cancel current session."""
         if self.agent:
             await self.agent.cancel()
+            await self.agent.shutdown()
             try:
                 self.agent.save_session()
             except Exception:
@@ -2103,6 +2421,16 @@ class CDHACPAdapter:
             self._send_available_commands()
         return {"modeId": mode_id}
 
+    async def session_clear_todos(self, session_id: str):
+        """Clear all todos in the current session."""
+        if self.agent:
+            tm = getattr(self.agent, "_todo_manager", None)
+            if tm:
+                tm.clear_todos()
+            self.agent.save_todos_to_project()
+            self._emit_plan_update_to_tui()
+        return {"cleared": True}
+
     # ── Terminal RPC stubs ──────────────────────────────────────────
     async def terminal_create(
         self, session_id: str, terminal_id: str, command: str, args: list[str] | None = None,
@@ -2134,6 +2462,8 @@ class JSONRPCServer:
             "session/cancel": self._handle_session_cancel,
             "session/save": self._handle_session_save,
             "session/set_mode": self._handle_session_set_mode,
+            "session/clear_todos": self._handle_session_clear_todos,
+            "session/load_earlier": self._handle_session_load_earlier,
             "session/ask_user_answer": self._handle_ask_user_answer,
             "terminal/create": self._handle_terminal_create,
             "terminal/kill": self._handle_terminal_kill,
@@ -2208,6 +2538,18 @@ class JSONRPCServer:
             params.get("modeId"),
         )
 
+    async def _handle_session_clear_todos(self, params: dict):
+        return await self.adapter.session_clear_todos(
+            params.get("sessionId"),
+        )
+
+    async def _handle_session_load_earlier(self, params: dict):
+        return await self.adapter.session_load_earlier(
+            params.get("sessionId"),
+            params.get("offset", 0),
+            params.get("limit", 50),
+        )
+
     async def _handle_terminal_create(self, params: dict):
         return await self.adapter.terminal_create(
             params.get("sessionId"),
@@ -2247,12 +2589,18 @@ class JSONRPCServer:
 async def _main():
     adapter = CDHACPAdapter()
     server = JSONRPCServer(adapter)
-    prompt_task: asyncio.Task | None = None
+
+    # Track in-flight prompt tasks by request id so that:
+    # - session/cancel can target the correct task
+    # - EOF can cancel & await all remaining tasks
+    prompt_tasks: dict[str | int, asyncio.Task] = {}
 
     async def _run_prompt(req: dict):
         try:
             result = await server._handle_session_prompt(req.get("params", {}))
             return {"jsonrpc": "2.0", "result": result, "id": req.get("id")}
+        except asyncio.CancelledError:
+            raise
         except Exception as e:
             import traceback
             tb = traceback.format_exc()
@@ -2264,6 +2612,13 @@ async def _main():
     while True:
         line = await asyncio.to_thread(sys.stdin.readline)
         if not line:
+            # EOF: cancel all in-flight prompts and exit
+            for p_req_id, p_task in prompt_tasks.items():
+                if not p_task.done():
+                    p_task.cancel()
+            if prompt_tasks:
+                await asyncio.gather(*prompt_tasks.values(), return_exceptions=True)
+                prompt_tasks.clear()
             break
 
         line = line.strip()
@@ -2294,10 +2649,34 @@ async def _main():
             if method == "session/prompt":
                 # Run prompt in background so main loop stays responsive
                 # to cancel notifications on stdin
-                prompt_task = asyncio.create_task(_run_prompt(req))
-                def _on_prompt_done(t, req=req):
+                task = asyncio.create_task(_run_prompt(req))
+                prompt_tasks[req_id] = task
+
+                def _on_prompt_done(t, req=req, rid=req_id):
+                    prompt_tasks.pop(rid, None)
                     try:
                         resp = t.result()
+                    except asyncio.CancelledError:
+                        # Prompt was cancelled (session/cancel). Send a
+                        # stopReason=cancelled response so the TUI's pending
+                        # session/prompt request resolves and the turn ends
+                        # cleanly — otherwise the TUI hangs forever waiting
+                        # for a response that never comes.
+                        info_log(
+                            "[ACP-CANCEL] _on_prompt_done CancelledError raised; "
+                            "req_id=%s subagent_fwd=%s",
+                            req.get("id"), dict(adapter._subagent_fwd_count),
+                        )
+                        if req.get("id") is not None:
+                            try:
+                                print(json.dumps({
+                                    "jsonrpc": "2.0",
+                                    "result": {"stopReason": "cancelled"},
+                                    "id": req["id"],
+                                }), flush=True)
+                            except (TypeError, ValueError, OSError):
+                                pass
+                        return
                     except Exception as exc:
                         _dump_crash("_on_prompt_done")
                         debug_log(f"Prompt task raised unhandled exception: {exc}", exc_info=True)
@@ -2308,10 +2687,30 @@ async def _main():
                         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)
+                task.add_done_callback(_on_prompt_done)
             elif method == "session/cancel":
-                if prompt_task and not prompt_task.done():
+                # session/cancel is a notification (no id), so req_id is None.
+                # prompt_tasks is keyed by request id; find any in-flight task.
+                if req_id is not None:
+                    target_task = prompt_tasks.get(req_id)
+                else:
+                    target_task = next(
+                        (t for t in prompt_tasks.values() if not t.done()),
+                        None,
+                    )
+                info_log(
+                    "[ACP-CANCEL] received session/cancel; "
+                    "req_id=%s task_exists=%s task_done=%s",
+                    req_id, "yes" if target_task else "no",
+                    target_task.done() if target_task else "n/a",
+                )
+                if target_task and not target_task.done():
                     adapter.cancel_prompt()
+                    info_log("[ACP-CANCEL] calling prompt_task.cancel() now")
+                    target_task.cancel()
+                    info_log("[ACP-CANCEL] prompt_task.cancel() returned")
+                else:
+                    info_log("[ACP-CANCEL] no in-flight prompt_task to cancel")
                 # Notification (no id) — nothing to respond with
             else:
                 response = await server.handle_request(req)
@@ -2324,6 +2723,20 @@ async def _main():
 
 
 def main():
+    # Initialise file logging ONCE at adapter entry.  Previously the ACP
+    # subprocess never called ``setup_logging`` (only the ``cli`` command
+    # path did), so every ``logger.debug(...)`` / ``debug_log(...)`` call
+    # in the engine/provider/ACP layers was silently dropped and
+    # ``~/.onecode/logs/onecode.log`` stayed empty during live reproductions.
+    # Honour the same ``CDH_LOG_LEVEL`` env var as the CLI so users can
+    # turn on DEBUG diagnostics without code changes.
+    import os
+    from onecode.cli import setup_logging
+    setup_logging(os.environ.get("CDH_LOG_LEVEL", "INFO"))
+    info_log(
+        "[ACP-INIT] cdh_acp adapter starting; log_level=%s pid=%d",
+        os.environ.get("CDH_LOG_LEVEL", "INFO"), os.getpid(),
+    )
     asyncio.run(_main())
 
 if __name__ == "__main__":