@scemoon/cdh 1.0.4 → 1.0.6

package/onecode/agent/agents/types.py

@@ -191,9 +191,8 @@ class GeneralAgent(AgentConfig):
             permission_bash=AgentPermission.ALLOW,
             permission_read=AgentPermission.ALLOW,
             permission_task=AgentPermission.DENY,
-            permission_question=AgentPermission.DENY,
-            permission_todowrite=AgentPermission.DENY,
-            disallowed_tools=["Spawn", "Agent", "AskUser"],
+            permission_question=AgentPermission.ALLOW,
+            disallowed_tools=["Spawn", "Agent", "AskUser", "TodoCreate", "TodoGet", "TodoList", "TodoUpdate", "TodoOutput", "TodoStop", "TodoClear"],
         )
 
 
@@ -208,8 +207,7 @@ class ExploreAgent(AgentConfig):
             permission_read=AgentPermission.ALLOW,
             permission_task=AgentPermission.DENY,
             permission_question=AgentPermission.DENY,
-            permission_todowrite=AgentPermission.DENY,
-            disallowed_tools=["Spawn", "Agent", "AskUser"],
+            disallowed_tools=["Spawn", "Agent", "AskUser", "TodoCreate", "TodoGet", "TodoList", "TodoUpdate", "TodoOutput", "TodoStop", "TodoClear"],
             hidden=True,
         )
 
@@ -227,8 +225,7 @@ class ScoutAgent(AgentConfig):
             permission_websearch=AgentPermission.ALLOW,
             permission_task=AgentPermission.DENY,
             permission_question=AgentPermission.DENY,
-            permission_todowrite=AgentPermission.DENY,
-            disallowed_tools=["Spawn", "Agent", "AskUser"],
+            disallowed_tools=["Spawn", "Agent", "AskUser", "TodoCreate", "TodoGet", "TodoList", "TodoUpdate", "TodoOutput", "TodoStop", "TodoClear"],
             hidden=True,
         )
 
@@ -324,7 +321,7 @@ SUBAGENT_CONSTRAINTS = """
 You are running as a subagent spawned by a parent agent via the Spawn tool.
 - You CANNOT spawn subagents (Spawn tool is disabled).
 - You CANNOT execute batched tool calls (Agent tool is disabled).
-- You CANNOT manage task plans (TodoCreate/TodoUpdate/TodoStop are disabled).
+- You CANNOT manage todos (all Todo* tools are disabled). The parent owns the shared plan.
 - You CANNOT interact with the user (AskUser is disabled).
 - You are a leaf node in the agent hierarchy. Execute the task in your prompt
   and return a structured SUMMARY/CHANGES/EVIDENCE/RISKS/BLOCKERS response.
@@ -404,9 +401,10 @@ Rules:
 - **WebSearch**: websearch(query) - Search the web and return results.
 
 ### Agent
-- **Task**: task(agent_type, prompt) - Spawn subagent to handle subtask.
+- **Spawn**: spawn(agent_type, prompt) - Delegate execution of a complex todo to a specialized subagent (isolated context). Use for multi-file/multi-step work. Then TodoUpdate(status="completed").
 - **Agent**: agent(calls, stop_on_error=True) - Execute a batch of tool calls as an atomic step. Each call includes {name, input}. Halts on first error when stop_on_error is true.
 - **ToolSearch**: tool_search(query) - Search for available tools by keyword.
+- **CodebaseSearch**: codebase_search(query, top_k=5) - Search the indexed codebase for code relevant to a query. Returns code chunks with file paths and line numbers. Use this to find relevant code before making changes.
 - **Skill**: skill(name) - Load skill by name.
 
 ### Communication
@@ -469,14 +467,15 @@ Rules:
 - **ConfigRead**: config_read(key) - Read configuration values.
 - **ConfigWrite**: config_write(key, value) - Set allowed configuration values (does NOT expose secrets).
 
-### Tasks & Planning (CDH)
-- **TodoCreate**: todo_create(subject, description, activeForm="", metadata={}) - Create a task. Returns task id.
-- **TodoGet**: todo_get(taskId) - Retrieve a task by ID.
-- **TodoList**: todo_list() - List all tasks with status, owner, and blockers.
-- **TodoUpdate**: todo_update(taskId, subject, description, activeForm, status, owner, addBlocks, addBlockedBy, metadata, output) - Update task fields and dependencies.
-- **TodoOutput**: todo_output(task_id) - Get output from a task.
-- **TodoStop**: todo_stop(task_id) - Stop a running task.
-- **Spawn**: spawn(agent_type, prompt) - Delegate a subtask to a specialized subagent.
+### Planning (Todo) & Delegation (Spawn)
+- **TodoCreate**: todo_create(subject, description, activeForm="", metadata={}) - Create a todo (plan item). ALL tasks use TodoCreate; persisted to .cdh/todos.json and mirrored to sidebar Plan. Returns todo id.
+- **TodoGet**: todo_get(taskId) - Retrieve a todo by ID.
+- **TodoList**: todo_list() - List all todos with status, owner, and blockers.
+- **TodoUpdate**: todo_update(taskId, subject, description, activeForm, status, owner, addBlocks, addBlockedBy, metadata, output) - Update todo fields, status, and dependencies.
+- **TodoOutput**: todo_output(taskId) - Get output from a todo.
+- **TodoStop**: todo_stop(taskId) - Stop a running todo.
+- **TodoClear**: todo_clear() - Clear ALL todos and start a fresh blank plan.
+- **Spawn**: spawn(agent_type, prompt) - Delegate EXECUTION of a complex todo to a specialized subagent (isolated context). Not a plan replacement — execute the todo, then TodoUpdate(status="completed").
 """
 
 def filter_tool_descriptions(
@@ -518,161 +517,45 @@ def filter_tool_descriptions(
     return "\n".join(result_lines)
 
 
-REACT_CYCLE = """
-## ReAct Cycle — 思考 → 行动 → 观察
-
-You operate in a **ReAct loop with Chain of Thought (CoT) reasoning**:
-
-```
-┌────────────────────────────────────────────────────┐
-│  ╭──────────╮    ╭──────────╮    ╭──────────╮      │
-│  │  Thought  │ →  │  Action  │ →  │Observa-  │      │
-│  │ (思考)    │    │ (行动)   │    │tion(观察)│ ──→  │
-│  ╰──────────╯    ╰──────────╯    ╰──────────╯      │
-│       ↑                   ↓ (cycle continues)      │
-│       │                                            │
-│       └──────── Feedback Loop ────────────────────┘ │
-└────────────────────────────────────────────────────┘
-```
-
-### Thought Phase (思考阶段)
-Before any action, reason step by step inside `<thinking>`:
-1. **Current state**: What do I know? What has been done? What are the results?
-2. **Goal**: What needs to be accomplished next?
-3. **Plan**: How should I approach it? What's the smallest next step?
-4. **Routing — choose by complexity**:
-   - **Simple / single-step** → use a direct read/search/exec tool, optionally
-     track with `TodoCreate` so the sidebar shows progress.
-   - **Complex / multi-step** → use `Spawn(agent_type, prompt)` to delegate to
-     a focused subagent.
-   - **Multi-file refactor / new feature** → ALWAYS use `Spawn`.
-
-### Action Phase (行动阶段)
-Execute the chosen action. **Action types (in priority order)**:
-1. **Delegate via Spawn** (complex work): `Spawn(agent_type="general"|"explore"|"scout", prompt="...")`.
-2. **Track via Todo** (simple work): `TodoCreate(subject, description, activeForm, metadata)` and `TodoUpdate(...)`. The sidebar shows progress to the user.
-3. **Research directly**: `Read()` / `Grep()` / `Glob()` / `WebFetch()` / `WebSearch()` for single-step information needs.
-4. **Direct execute**: Only for trivial single-step operations that cannot justify a subagent or a todo.
-
-### Observation Phase (观察阶段)
-The tool result IS your observation. Process it:
-- **Success**: Note key outputs, update todo status via `TodoUpdate(status="completed")`, move to next step
-- **Error**: Diagnose root cause, decide: retry with fix | modify plan | ask user
-- **Partial**: Extract what worked, adjust approach for remaining work
-
-### Core Rules
-- **ALL reasoning goes in `<thinking>`**: Never narrate "I will now..." in visible text
-- **Route by complexity**: Simple → Todo, complex → Spawn. Never blindly use Spawn for trivial work.
-- **One responsibility per Spawn / Todo**: Each unit should have a clear, focused goal
-- **Pass context**: Include relevant context (file paths, findings) in Spawn prompts and Todo descriptions
-- **CoT every cycle**: Every turn starts with `<thinking>` reasoning before any action
-"""
-
-PLAN_INSTRUCTIONS = """
-## ReAct Workflow (Thought → Action → Observation)
-
-The agent is a **ReAct** implementation: each cycle is **Thought → Action → Observation**.
-**Human-in-the-loop** means you involve the user at key decision points.
-
-```
-Loop:
-  Thought     → Reason step by step (CoT) inside <thinking>
-                Always ask: "Is this simple (Todo) or complex (Spawn)?"
-  Action      → Simple → TodoCreate + direct tool
-                Complex → Spawn(agent_type, prompt)
-  Observation → Incorporate results into the next Thought
-```
-
-Plan/Build/Solo are different configurations of this same ReAct engine:
-- **plan** mode: hard gate — execution tools blocked until a todo plan exists.
-- **build**/**solo** mode: soft gate — execution allowed but planning encouraged.
-
-**Routing principle**:
-- **Simple todo** = 1 tool call, 1 file, ≤2 lines of code change, single Read/Glob. Use `TodoCreate` + direct tool.
-- **Complex work** = >1 tool call, multi-file, research, refactor, new feature. Use `Spawn(agent_type, prompt)`.
-- When in doubt, choose `Spawn`. Subagents encapsulate work cleanly; todos are for visible progress on the main agent's own work.
-
----
+REACT_WORKFLOW = """
+## Workflow: 思考 → Todo → 行动 (per-Round)
 
-### Step 1: Think (CoT) — Chain of Thought Reasoning
+Each round: `<thinking>` → Todo ops → tool execution → TodoUpdate.
+Tool results from the previous round are already in context — review them
+at the start of `<thinking>`. No separate "Observation" step is needed.
 
-Analyze the request with step-by-step reasoning before any action.
+### Round Structure
 
-- Wrap ALL reasoning in `<thinking>...</thinking>` — visible text is for the user only
-- Think step by step: What's the goal? What's the current state? Is this simple or complex?
-- **Decide routing**:
-  - For simple work → proceed to `TodoCreate` then act directly.
-  - For complex work → proceed to spawn subagents.
-- Read relevant files, grep for patterns, glob for structure
-- Use `webfetch`/`websearch` for external APIs or docs
-- Delegate deep research to `explore`/`scout` subagents via `Spawn`
-- Ask the user via `AskUser` if requirements are ambiguous
-- Do NOT create todos yet — first understand what is needed
+**思考** (inside `<thinking>`):
+1. Review: what did the last round's tools produce? Any errors to address?
+2. Progress: which todos are done, which are pending?
+3. Decide: what is the single next action? Pick: direct tool or `Spawn`?
 
----
+**Todo** (before acting):
+- No todo for this work? → `TodoCreate` first.
+- Todo exists? → advance it (`in_progress`).
+- Completed work? → `TodoUpdate(status="completed")` immediately.
+- Do NOT mark a todo as completed unless its work was actually executed.
 
-### Step 2: Act (Plan) — Create the Todo Plan
+**行动** (execute):
+- Simple (1 tool, 1 file) → call the tool directly.
+- Complex (multi-step/research) → `Spawn(agent_type, prompt)` to delegate.
+- Spawn executes a todo — it does not replace one.
 
-Once you understand the work, create a complete todo plan via `TodoCreate()`.
-
-**Routing Granularity Rules**
-- One todo = one focused unit of work (file, function, or concern).
-- Each todo: decide at creation time whether it should be done by the main agent or delegated to a Spawn subagent.
-  - Mark delegatable todos with `metadata={"delegate_to": "general"}` so the main agent knows to use `Spawn` for that item.
-  - Simple todos (1 tool call) stay with the main agent.
-- If a todo needs >5 tool calls, split it into smaller todos.
-
-**Creating Todos**
-```
-TodoCreate(subject="<verb + noun>", description="<what + acceptance criteria>",
-           metadata={"priority": "high|medium|low",
-                     "effort": "small|medium|large",
-                     "delegate_to": "general|explore|scout|main"})
-```
-- Set `addBlockedBy` on dependent todos so the dependency DAG is clear
-- **Create ALL todos upfront** before presenting the plan to the user
-
-**Present Plan for Review (Human-in-the-loop)**
-After creating all todos, use `AskUser` to summarize the plan and get approval
-before executing.
-Wait for user approval before moving to execution.
-
----
-
-### Step 3: Act (Execute) — Route by Complexity
-
-Execute each todo using the right tool for the work:
-
-- **Simple todos** (single tool call): execute directly with `Read`/`Edit`/`Bash`, then `TodoUpdate(status="completed")`.
-- **Complex todos** (multi-step, multi-file, research):
-  `Spawn(agent_type="general", prompt="Detailed instructions with context...")`.
-  Wait for the subagent's SUMMARY/CHANGES/EVIDENCE/RISKS/BLOCKERS output, then
-  `TodoUpdate(status="completed")`.
-- Use `general` subagent for implementation, `explore` for code search, `scout` for research
-- Pass enough context in the Spawn prompt: relevant file paths, code snippets, requirements
-- After each todo, advance its status: `pending` → `in_progress` → `completed`
-
----
-
-### Step 4: Observe — Feed Results Back
-
-After every Action, the tool result is your **Observation**. Use it to inform the
-next Thought:
-- Spawn subagent completed → review SUMMARY/CHANGES/EVIDENCE/RISKS/BLOCKERS sections
-- TodoCreate succeeded → proceed to present plan or execute the next todo
-- Error occurred → diagnose and decide: retry, modify plan, or ask the user
-- User denied an action → adapt the todo plan accordingly
-
----
+### Routing
+- Every task = a `TodoCreate`. No work without a todo.
+- `Spawn` = execution delegation for complex todos only.
+"""
 
-### Rules
+PLAN_GATE_HARD = """
+### plan mode: hard gate
+Execution tools (Write/Edit/Insert/ApplyPatch/Bash) are BLOCKED until a todo plan exists.
+Create ALL todos upfront with `TodoCreate`, present for user review, then execute.
+"""
 
-- **No top-level planning prose**: All planning goes through `TodoCreate`/`TodoUpdate` so the sidebar renders it.
-- **CoT in `<thinking>`**: Every turn starts with chain-of-thought reasoning inside `<thinking>`. Never narrate "I will now…" in visible text.
-- **Route by complexity**: Simple → Todo + direct tool. Complex → Spawn.
-- **Todo status discipline**: `pending` → `in_progress` → `completed`. Every todo transitions through all three.
-- **No execution without a plan**: Write/Edit/Insert/ApplyPatch/Bash require todos. Create todos first.
-- **Human at key decisions**: Present the plan, get approval, then execute. Report progress as you go.
+PLAN_GATE_SOFT = """
+### build/solo mode: soft gate
+Execution is allowed but planning is encouraged. Create todos first via `TodoCreate`.
 """
 
 COMPACTION_INSTRUCTIONS = """

package/onecode/agent/attachments.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import fnmatch
 import mimetypes
 from dataclasses import dataclass, field
 from pathlib import Path

package/onecode/agent/cdh_loader.py

@@ -11,7 +11,7 @@ def _walk_up_parents(workspace_root: Path):
     """Yield workspace root, then git root.
 
     Unlike :class:`~onecode.skills.loader.SkillLoader` we deliberately do
-    **not** yield ``Path.home()`` — the global ``~/.cdh/`` is the onecode
+    **not** yield ``Path.home()`` — the global ``~/.onecode/`` is the onecode
     user-config directory, not a project-level ``.cdh/``, so including it
     would cause false-positive matches.
     """
@@ -61,6 +61,16 @@ class CdhProjectLoader:
                 return candidate
         return None
 
+    @staticmethod
+    def find_cdh_dir_for_todos(workspace_root: Path) -> Optional[Path]:
+        """Find ``.cdh/`` strictly at *workspace_root*, without walking up.
+
+        Used for todo persistence so sub-projects never accidentally load
+        or write to a parent project's ``.cdh/todos.json``.
+        """
+        candidate = workspace_root.resolve() / CdhProjectLoader.CDH_DIRNAME
+        return candidate if candidate.is_dir() else None
+
     # ── file readers ───────────────────────────────────────────
 
     @staticmethod
@@ -100,17 +110,6 @@ class CdhProjectLoader:
             encoding="utf-8",
         )
 
-    @staticmethod
-    def get_skill_content(cdh_dir: Path) -> str:
-        """Read ``.cdh/SKILL.md`` if it exists."""
-        skill_path = cdh_dir / "SKILL.md"
-        if skill_path.exists():
-            try:
-                return skill_path.read_text(encoding="utf-8")
-            except Exception:
-                pass
-        return ""
-
     # ── last-session persistence ───────────────────────────────
 
     @staticmethod
@@ -191,7 +190,6 @@ class CdhProjectLoader:
 
         config = CdhProjectLoader.load_project_config(cdh_dir)
         state = CdhProjectLoader.load_project_state(cdh_dir)
-        skill = CdhProjectLoader.get_skill_content(cdh_dir)
 
         parts = ["## Project State (.cdh)"]
         name = config.get("name", cdh_dir.parent.name)
@@ -207,8 +205,6 @@ class CdhProjectLoader:
             parts.append(f"- Config: {json.dumps(config, ensure_ascii=False)}")
         if state:
             parts.append(f"- State: {json.dumps(state, ensure_ascii=False)}")
-        if skill:
-            parts.append(f"\n--- .cdh/SKILL.md ---\n{skill}")
 
         parts.append(
             "\n**Important**: Work directly in the project root directory shown above. "
@@ -229,8 +225,12 @@ class CdhProjectLoader:
     ) -> Path:
         """Scaffold a ``.cdh/`` directory inside *workspace_root*.
 
-        Creates ``.cdh/config.yaml``, ``.cdh/state.json``, and a
-        stub ``.cdh/SKILL.md``.
+        Creates ``.cdh/config.yaml`` and ``.cdh/state.json``.
+
+        Project-level agent instructions live in the workspace-root
+        ``AGENTS.md`` (read by :mod:`onecode.agent.project_doc`); we
+        intentionally do **not** create a stub inside ``.cdh/`` — that
+        would split a single source of truth across two files.
 
         If *workspace_root* is inside a directory that is already a
         ``.cdh/`` project, a warning is printed and the existing project
@@ -264,12 +264,4 @@ class CdhProjectLoader:
         state_path = cdh_dir / CdhProjectLoader.STATE_FILENAME
         state_path.write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8")
 
-        skill_path = cdh_dir / "SKILL.md"
-        if not skill_path.exists():
-            skill_path.write_text(
-                f"# {name} — Project Instructions\n\n"
-                "Add project-specific agent instructions here.\n",
-                encoding="utf-8",
-            )
-
         return cdh_dir

package/onecode/agent/context.py

@@ -217,15 +217,20 @@ class ContextManager:
                 for b in m.content:
                     if isinstance(b, dict) and b.get("type") == "tool_result":
                         content = b.get("content", "")
-                        if isinstance(content, str) and len(content) > 500:
-                            b["content"] = content[:500] + "\n... [truncated]"
+                        if isinstance(content, str) and len(content) > 2000:
+                            # Preserve full output if it contains code blocks
+                            # or structured JSON results.
+                            if "```" not in content and not content.lstrip().startswith("{"):
+                                b["content"] = content[:500] + "\n... [truncated]"
 
     def _tier_truncate_old(self, msgs: list[Message], keep_recent: int = 10) -> None:
         if len(msgs) <= keep_recent:
             return
         for m in msgs[:-keep_recent]:
             if isinstance(m.content, str) and len(m.content) > 200:
-                m.content = m.content[:200] + "..."
+                # Preserve messages containing code blocks or structured data
+                if "```" not in m.content:
+                    m.content = m.content[:200] + "..."
             elif isinstance(m.content, list):
                 m.content = [b for b in m.content if isinstance(b, dict) and b.get("type") == "tool_use"]
                 if not m.content: