@scemoon/cdh 1.0.4 → 1.0.5

package/onecode/storage/activity.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
-import json
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
-from sqlalchemy import Column, String, Text, DateTime, JSON, create_engine
+from sqlalchemy import Column, String, DateTime, JSON, create_engine
 from sqlalchemy.orm import declarative_base, sessionmaker
 
-from onecode.config import CLOUD_DEV_HARNESS_DIR
+from onecode.config import ONECODE_DIR
 
 Base = declarative_base()
 
@@ -28,7 +27,7 @@ class ActivityRecord(Base):
 class ActivityRecorder:
     def __init__(self, db_path: Optional[Path] = None):
         if db_path is None:
-            db_path = CLOUD_DEV_HARNESS_DIR / "sessions" / "cdh.db"
+            db_path = ONECODE_DIR / "sessions" / "cdh.db"
         db_path.parent.mkdir(parents=True, exist_ok=True)
         self.engine = create_engine(f"sqlite:///{db_path}")
         Base.metadata.create_all(self.engine)

package/onecode/storage/session.py

@@ -9,14 +9,13 @@ from typing import Optional
 from sqlalchemy import (
     Column,
     String,
-    Text,
     DateTime,
     JSON,
     create_engine,
 )
-from sqlalchemy.orm import declarative_base, Session as SASession, sessionmaker
+from sqlalchemy.orm import declarative_base, sessionmaker
 
-from onecode.config import CLOUD_DEV_HARNESS_DIR
+from onecode.config import ONECODE_DIR
 
 Base = declarative_base()
 
@@ -43,7 +42,7 @@ class SessionRecord(Base):
 class SessionStore:
     def __init__(self, db_path: Optional[Path] = None):
         if db_path is None:
-            db_path = CLOUD_DEV_HARNESS_DIR / "sessions" / "cdh.db"
+            db_path = ONECODE_DIR / "sessions" / "cdh.db"
         db_path.parent.mkdir(parents=True, exist_ok=True)
         self.engine = create_engine(f"sqlite:///{db_path}")
         Base.metadata.create_all(self.engine)

package/onecode/tasks/manager.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import uuid
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Optional
@@ -16,8 +16,6 @@ from onecode.tasks.models import (
     TaskChecklistState,
     TaskGateRecord,
     TaskToolCallSummary,
-    TodoItem,
-    TodoStatus,
 )
 
 
@@ -56,6 +54,8 @@ class TaskManager:
         self._storage_path = storage_path or Path.home() / ".cdh" / "tasks"
         self._executor: Optional[TaskExecutor] = None
         self._worker_task: Optional[asyncio.Task] = None
+        self._semaphore = asyncio.Semaphore(5)
+        self._shutdown: bool = False
 
     def set_executor(self, executor: TaskExecutor) -> None:
         self._executor = executor
@@ -90,11 +90,14 @@ class TaskManager:
             self._worker_task = asyncio.create_task(self._worker_loop())
 
     async def _worker_loop(self) -> None:
-        while True:
+        while not self._shutdown:
             try:
-                task = await self._queue.get()
+                task = await asyncio.wait_for(self._queue.get(), timeout=30)
                 if task.id not in self._running:
-                    self._running[task.id] = asyncio.create_task(self._run_task(task))
+                    async with self._semaphore:
+                        self._running[task.id] = asyncio.create_task(self._run_task(task))
+            except asyncio.TimeoutError:
+                continue
             except asyncio.CancelledError:
                 break
             except Exception as e:
@@ -112,7 +115,10 @@ class TaskManager:
             if self._executor:
                 cancel = asyncio.Event()
                 events: asyncio.Queue = asyncio.Queue()
-                result = await self._executor.execute(execution, events, cancel)
+                result = await asyncio.wait_for(
+                    self._executor.execute(execution, events, cancel),
+                    timeout=300,
+                )
                 task_record.status = TaskStatus.COMPLETED if result.get("success") else TaskStatus.FAILED
                 task_record.error = result.get("error")
             else:
@@ -147,8 +153,7 @@ class TaskManager:
             return list(self._tasks.values())
         return [t for t in self._tasks.values() if t.status == status]
 
-    def add_todo_to_task(self, task_id: str, content: str, status: str = "pending") -> Optional["TaskChecklistItem"]:
-        from onecode.tasks.models import TaskChecklistItem
+    def add_todo_to_task(self, task_id: str, content: str, status: str = "pending") -> Optional["TaskChecklistItem"]:  # noqa: F821
         task = self._tasks.get(task_id)
         if not task:
             return None
@@ -211,9 +216,17 @@ class TaskManager:
         return True
 
     async def stop(self) -> None:
+        self._shutdown = True
         if self._worker_task:
             self._worker_task.cancel()
             try:
                 await self._worker_task
             except asyncio.CancelledError:
-                pass
+                pass
+        if self._running:
+            results = await asyncio.gather(
+                *self._running.values(), return_exceptions=True,
+            )
+            for tid, res in zip(list(self._running.keys()), results):
+                if isinstance(res, Exception):
+                    logger.warning("Task %s exited with error: %s", tid, res)

package/onecode/trace/tracer.py

@@ -5,10 +5,9 @@ import time
 import uuid
 from contextlib import contextmanager
 from datetime import datetime, timezone
-from pathlib import Path
 from typing import Any, Optional
 
-from onecode.config import CLOUD_DEV_HARNESS_DIR
+from onecode.config import ONECODE_DIR
 
 
 class Span:
@@ -55,7 +54,7 @@ class Tracer:
         self.recording: bool = False
         self.spans: list[Span] = []
         self.stack: list[str] = []
-        self.trace_dir = CLOUD_DEV_HARNESS_DIR / "traces"
+        self.trace_dir = ONECODE_DIR / "traces"
         self.trace_dir.mkdir(parents=True, exist_ok=True)
         self._otlp_endpoint: Optional[str] = None
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scemoon/cdh",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Cloud Dev Harness - cloud-native development Agent framework",
   "keywords": ["ai", "agent", "cloud", "development", "cli", "tui"],
   "license": "MIT",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cloud-dev-harness"
-version = "1.0.0"
+version = "1.0.5"
 description = "Cloud Dev Harness - cloud-native development Agent framework with A2TUI"
 requires-python = ">=3.14.2"
 dependencies = [
@@ -57,6 +57,9 @@ onecode = [
     "builtin_skills/**/*",
 ]
 
+[tool.ruff]
+exclude = ["tui/", "dist/", ".venv/"]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 
@@ -66,5 +69,6 @@ dev = [
     "pyinstrument>=5.1.1",
     "pytest>=9.0.3",
     "pytest-asyncio>=1.4.0",
+    "pytest-cov>=6.0.0",
     "textual-dev>=1.8.0",
 ]

package/tui/acp/agent.py

@@ -28,7 +28,6 @@ from tui.acp import messages
 from tui.acp.prompt import build as build_prompt
 from tui import messages as tui_messages
 from tui.db import DB
-from tui import paths
 from tui import constants
 from tui.answer import Answer
 
@@ -88,6 +87,7 @@ class Agent(AgentBase):
         self._message_target: MessagePump | None = None
 
         self._terminal_count: int = 0
+        self.session_load_info: dict = {}
 
     @property
     def command(self) -> str | None:
@@ -122,9 +122,14 @@ class Agent(AgentBase):
             request: JSONRPC request object.
 
         """
-        assert self._process is not None, "Process should be present here"
+        if self._process is None:
+            logger.warning(
+                "Cannot send request %s: agent process is not running",
+                request.body,
+            )
+            return
 
-        logger.debug("[client] %s", request.body)
+        logger.info("[client] send: %s", request.body)
         if (stdin := self._process.stdin) is not None:
             stdin.write(b"%s\n" % request.body_json)
 
@@ -542,61 +547,64 @@ class Agent(AgentBase):
                 if (task := asyncio.current_task()) is not None:
                     tasks.discard(task)
 
-        while line := await process.stdout.readline():
-            # This line should contain JSON, which may be:
-            #   A) a JSONRPC request
-            #   B) a JSONRPC response to a previous request
-            if not line.strip():
-                continue
-
-            try:
-                line_str = line.decode("utf-8")
-            except Exception as error:
-                logger.error("Unable to decode utf-8 from agent: %s", error)
-                continue
-
-            logger.debug("[agent] %s", line_str.rstrip())
-            try:
-                agent_data: jsonrpc.JSONType = json.loads(line_str)
-            except Exception as error:
-                logger.error("Failed to decode JSON from agent: %s", error)
-                continue
-
-            if isinstance(agent_data, dict):
-                if "result" in agent_data or "error" in agent_data:
-                    # Wait for pending notification dispatch tasks so all ACP
-                    # messages are queued before the response future resolves.
-                    if tasks:
-                        await asyncio.gather(*tasks, return_exceptions=True)
-                        tasks.clear()
-                    API.process_response(agent_data)
+        try:
+            while line := await process.stdout.readline():
+                # This line should contain JSON, which may be:
+                #   A) a JSONRPC request
+                #   B) a JSONRPC response to a previous request
+                if not line.strip():
                     continue
 
-            elif isinstance(agent_data, list):
-                if not all(isinstance(datum, dict) for datum in agent_data):
-                    logger.error("Agent sent invalid data: %r", agent_data)
+                try:
+                    line_str = line.decode("utf-8")
+                except Exception as error:
+                    logger.error("Unable to decode utf-8 from agent: %s", error)
                     continue
 
-            if not isinstance(agent_data, dict):
-                logger.error("Invalid JSON from agent: %r", agent_data)
-                continue
+                logger.debug("[agent] %s", line_str.rstrip())
+                try:
+                    agent_data: jsonrpc.JSONType = json.loads(line_str)
+                except Exception as error:
+                    logger.error("Failed to decode JSON from agent: %s", error)
+                    continue
 
-            if not isinstance(agent_data, dict):
-                logger.error("Invalid JSON from agent: %r", agent_data)
-                continue
+                if isinstance(agent_data, dict):
+                    if "result" in agent_data or "error" in agent_data:
+                        # Wait for pending notification dispatch tasks so all ACP
+                        # messages are queued before the response future resolves.
+                        if tasks:
+                            await asyncio.gather(*tasks, return_exceptions=True)
+                            tasks.clear()
+                        API.process_response(agent_data)
+                        continue
+
+                elif isinstance(agent_data, list):
+                    if not all(isinstance(datum, dict) for datum in agent_data):
+                        logger.error("Agent sent invalid data: %r", agent_data)
+                        continue
+
+                if not isinstance(agent_data, dict):
+                    logger.error("Invalid JSON from agent: %r", agent_data)
+                    continue
 
-            # By this point we know it is a JSON RPC call
-            assert isinstance(agent_data, dict)
-            tasks.add(asyncio.create_task(call_jsonrpc(agent_data)))
-            await asyncio.sleep(0)
+                if not isinstance(agent_data, dict):
+                    logger.error("Invalid JSON from agent: %r", agent_data)
+                    continue
 
-        # Cancel all remaining tasks and wait for them to finish
-        for task in tasks:
-            task.cancel()
+                # By this point we know it is a JSON RPC call
+                assert isinstance(agent_data, dict)
+                tasks.add(asyncio.create_task(call_jsonrpc(agent_data)))
+                await asyncio.sleep(0)
+        except Exception as e:
+            logger.exception("Agent read loop failed: %s", e)
+        finally:
+            # Cancel all remaining tasks and wait for them to finish
+            for task in tasks:
+                task.cancel()
 
-        # Wait for all tasks to complete cancellation
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
+            # Wait for all tasks to complete cancellation
+            if tasks:
+                await asyncio.gather(*tasks, return_exceptions=True)
 
         if process.returncode:
             assert process.stderr is not None
@@ -691,6 +699,7 @@ class Agent(AgentBase):
             protocol=data["protocol"],
             meta=data["meta"],
         )
+        self.post_message(tui_messages.SessionUpdate(session_pk=self.session_pk))
         self._pending_session_data = None
         await self._save_last_session_to_cdh()
 
@@ -816,8 +825,19 @@ class Agent(AgentBase):
         self.post_message(messages.SessionReplay(active=True))
         try:
             response = await session_load_response.wait()
+            self.session_load_info = {
+                "total_messages": response.get("_total_messages", 0),
+                "visible_start": response.get("_visible_start", 0),
+            }
         finally:
-            self.post_message(messages.SessionReplay(active=False))
+            self.post_message(messages.SessionReplay(
+                active=False,
+                total_messages=self.session_load_info.get("total_messages", 0),
+                visible_count=self.session_load_info.get("total_messages", 0) - self.session_load_info.get("visible_start", 0),
+            ))
+
+        if error := response.get("error"):
+            logger.warning("Session load error: %s", error)
 
         if (modes := response.get("modes", None)) is not None:
             current_mode = modes["currentModeId"]
@@ -845,10 +865,20 @@ class Agent(AgentBase):
             await self._ensure_db_session()
 
         if session_title:
-            self.post_message(tui_messages.SessionUpdate(name=session_title))
+            self.post_message(tui_messages.SessionUpdate(name=session_title, session_pk=self.session_pk))
 
         await self._save_last_session_to_cdh()
 
+    async def acp_load_earlier_messages(self, offset: int, limit: int) -> None:
+        """Load a range of earlier messages from the current session."""
+        assert self.session_id is not None
+        with self.request():
+            response = api.session_load_earlier(self.session_id, offset, limit)
+        try:
+            await response.wait()
+        except jsonrpc.JSONRPCError:
+            pass
+
     async def acp_session_prompt(
         self, prompt: list[protocol.ContentBlock]
     ) -> str | None:
@@ -858,6 +888,14 @@ class Agent(AgentBase):
             The stop reason.
 
         """
+        if self._process is None:
+            self.post_message(
+                AgentFail(
+                    "Agent process is not running",
+                    "The agent subprocess has terminated. Restart the session to continue.",
+                )
+            )
+            return None
         with self.request():
             session_prompt = api.session_prompt(prompt, self.session_id)
         try:
@@ -908,6 +946,15 @@ class Agent(AgentBase):
     async def set_mode(self, mode_id: str) -> str | None:
         return await self.acp_session_set_mode(mode_id)
 
+    async def acp_session_clear_todos(self) -> dict:
+        """Clear all todos via the session/clear_todos RPC."""
+        if self.session_id is None:
+            return {"cleared": False}
+        with self.request():
+            response = api.session_clear_todos(self.session_id)
+        result = await response.wait()
+        return result or {"cleared": False}
+
     async def set_session_name(self, name: str) -> None:
         if self.session_pk is None:
             return
@@ -919,16 +966,36 @@ class Agent(AgentBase):
             if session.load():
                 session.name = name
                 session.save()
-        self.post_message(tui_messages.SessionUpdate(name=name))
+        self.post_message(tui_messages.SessionUpdate(name=name, session_pk=self.session_pk))
 
     async def acp_session_cancel(self) -> bool:
-        with self.request():
-            response = api.session_cancel(self.session_id, {})
+        """Send session/cancel notification to the agent subprocess.
+
+        Writes directly to stdin with drain() to ensure the message is
+        actually flushed through the pipe, unlike the Request path which
+        is synchronous and cannot drain.
+        """
+        if not self.session_id:
+            logger.info("[client] session/cancel: no session_id, skipping")
+            return False
+        cancel_msg = {
+            "jsonrpc": "2.0",
+            "method": "session/cancel",
+            "params": {"sessionId": self.session_id, "_meta": {}},
+        }
+        data = json.dumps(cancel_msg).encode("utf-8") + b"\n"
+        logger.info("[client] session/cancel: sending %s", cancel_msg)
+        stdin = self._process.stdin if self._process else None
+        if stdin is None:
+            logger.info("[client] session/cancel: no stdin pipe, skipping")
+            return False
+        stdin.write(data)
         try:
-            await response.wait()
-        except jsonrpc.APIError:
-            # No-op if there is nothing to cancel
+            await stdin.drain()
+        except OSError:
+            logger.info("[client] session/cancel: drain failed", exc_info=True)
             return False
+        logger.info("[client] session/cancel: sent successfully")
         return True
 
     async def cancel(self) -> bool:

package/tui/acp/api.py

@@ -59,3 +59,15 @@ def session_set_mode(sessionId: str, modeId: str) -> protocol.SetSessionModeResp
 def session_save(sessionId: str) -> dict:
     """Save the session state."""
     ...
+
+
+@API.method(name="session/clear_todos")
+def session_clear_todos(sessionId: str) -> dict:
+    """Clear all todos in the current session."""
+    ...
+
+
+@API.method(name="session/load_earlier")
+def session_load_earlier(sessionId: str, offset: int, limit: int) -> dict:
+    """Load a range of earlier messages from the current session."""
+    ...

package/tui/acp/messages.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 
 from asyncio import Future
-from typing import Any, Mapping, TYPE_CHECKING
+from typing import Mapping, TYPE_CHECKING
 from textual.message import Message
 
 import rich.repr
@@ -38,6 +38,8 @@ class Thinking(AgentMessage):
 class SessionReplay(AgentMessage):
     """Marks the start/end of a session replay (loading historical messages)."""
     active: bool
+    total_messages: int = 0
+    visible_count: int = 0
 
 
 @dataclass

package/tui/acp/prompt.py

@@ -6,54 +6,6 @@ from tui.prompt.extract import extract_paths_from_prompt
 from tui.prompt.resource import load_resource, ResourceError
 
 
-CLOUD_SPEC_SKILL_PATH = Path(__file__).resolve().parent.parent.parent / "cloud-spec-skill" / "SKILL.md"
-
-
-def _get_cloud_spec_content() -> str:
-    """Load cloud-spec-skill content."""
-    if CLOUD_SPEC_SKILL_PATH.exists():
-        return CLOUD_SPEC_SKILL_PATH.read_text(encoding="utf-8")
-    return ""
-
-
-def cloud_spec_skill_loaded() -> bool:
-    """Check if cloud-spec-skill SKILL.md exists."""
-    return CLOUD_SPEC_SKILL_PATH.exists()
-
-
-def ensure_cloud_spec_skill_installed() -> str | None:
-    """Ensure cloud-spec-skill is accessible to agents.
-
-    Checks if SKILL.md exists in repo and copies it to ~/.cdh/skills/ if needed,
-    or updates if the repo version is newer.
-    Returns error message if installation fails, None on success.
-    """
-    from onecode.skills.loader import USER_SKILLS_DIR
-
-    if not CLOUD_SPEC_SKILL_PATH.exists():
-        return None
-
-    skill_dest = USER_SKILLS_DIR / "cloud-spec-skill"
-    dest_skills_md = skill_dest / "SKILL.md"
-
-    if skill_dest.exists() and dest_skills_md.exists():
-        repo_mtime = CLOUD_SPEC_SKILL_PATH.stat().st_mtime
-        dest_mtime = dest_skills_md.stat().st_mtime
-        if dest_mtime >= repo_mtime:
-            return None
-
-    try:
-        import shutil
-
-        if skill_dest.exists():
-            shutil.rmtree(skill_dest)
-        skill_dest.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copytree(CLOUD_SPEC_SKILL_PATH.parent, skill_dest)
-        return None
-    except Exception as e:
-        return str(e)
-
-
 def build(project_path: Path, prompt: str) -> list[protocol.ContentBlock]:
     """Build the prompt structure and extract paths with the @ syntax.
 
@@ -66,14 +18,6 @@ def build(project_path: Path, prompt: str) -> list[protocol.ContentBlock]:
     """
     prompt_content: list[protocol.ContentBlock] = []
 
-    # Prepend cloud-spec-skill as system guidance
-    cloud_spec_content = _get_cloud_spec_content()
-    if cloud_spec_content:
-        prompt_content.append({
-            "type": "text",
-            "text": f"[System Guidance - Always follow these development standards]\n\n{cloud_spec_content}\n\n---\n\n"
-        })
-
     prompt_content.append({"type": "text", "text": prompt})
     for path, _, _ in extract_paths_from_prompt(prompt):
         if path.endswith("/"):
@@ -81,7 +25,6 @@ def build(project_path: Path, prompt: str) -> list[protocol.ContentBlock]:
         try:
             resource = load_resource(project_path, Path(path))
         except ResourceError:
-            # TODO: How should this be handled?
             continue
         uri = f"file://{resource.path.absolute().resolve()}"
         if resource.text is not None:

package/tui/acp/protocol.py

@@ -217,6 +217,11 @@ class ToolCall(SchemaDict, total=False, extra_items=Any):
     status: ToolCallStatus
     title: Required[str]
     toolCallId: Required[ToolCallId]
+    # Custom (non-ACP) field: when set, this tool call was invoked *inside* a
+    # subagent and the TUI should mount/update the ToolCall card inside the
+    # owning SubAgent widget (subagentId = the parent Spawn toolCallId) rather
+    # than in the main conversation.
+    subagentId: str
 
 
 # https://agentclientprotocol.com/protocol/schema#toolcallupdate
@@ -231,6 +236,7 @@ class ToolCallUpdate(SchemaDict, total=False, extra_items=Any):
     status: ToolCallStatus | None
     title: str | None
     toolCallId: Required[ToolCallId]
+    subagentId: str
 
 
 # https://agentclientprotocol.com/protocol/schema#param-tool-call