Fix tool parameter signatures and improve consistency

src/tools/config_tool.py

@@ -1,172 +1,287 @@
-"""ConfigTool - Runtime configuration management for Stack 2.9"""
+"""ConfigTool — runtime configuration management for Stack 2.9.
 
-import json
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from .base import BaseTool, ToolResult
-from .registry import tool_registry
-
-CONFIG_FILE = Path.home() / ".stack-2.9" / "config.json"
+Stores configuration in ~/.stack-2.9/config.json
 
+Operations:
+  - get    : retrieve a configuration value
+  - set    : set a configuration value
+  - list   : list all configuration keys and values
+  - delete : remove a configuration key
 
-def _load_config() -> Dict[str, Any]:
-    """Load config from disk."""
-    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
-    if CONFIG_FILE.exists():
-        return json.loads(CONFIG_FILE.read_text())
-    return {"settings": {}}
+Input schema:
+  operation : str — one of get, set, list, delete
+  key       : str — configuration key (required for get/set/delete)
+  value     : any — new value (required for set)
+"""
 
+from __future__ import annotations
 
-def _save_config(data: Dict[str, Any]) -> None:
-    """Save config to disk."""
-    CONFIG_FILE.write_text(json.dumps(data, indent=2))
-
+import json
+import os
+from typing import Any
 
-# Default settings
-DEFAULT_SETTINGS = {
-    "model": "Qwen/Qwen2.5-Coder-1.5B",
-    "temperature": 0.7,
-    "max_tokens": 2048,
-    "context_length": 32768,
-    "tools_enabled": True,
-    "voice_enabled": False,
-    "language": "en"
+from .base import BaseTool, ToolResult
+from .registry import get_registry
+
+TOOL_NAME = "Config"
+DATA_DIR = os.path.expanduser("~/.stack-2.9")
+CONFIG_FILE = os.path.join(DATA_DIR, "config.json")
+
+
+def _load_config() -> dict[str, Any]:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE) as f:
+                return json.load(f)
+        except Exception:
+            pass
+    return {}
+
+
+def _save_config(config: dict[str, Any]) -> None:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2, default=str)
+
+
+# Supported configuration keys and their metadata
+SUPPORTED_KEYS: dict[str, dict[str, Any]] = {
+    "theme": {
+        "type": "string",
+        "options": ["light", "dark", "system"],
+        "default": "system",
+        "description": "UI theme",
+    },
+    "model": {
+        "type": "string",
+        "description": "Default model to use",
+        "default": "",
+    },
+    "max_tokens": {
+        "type": "number",
+        "description": "Maximum tokens per response",
+        "default": 4096,
+    },
+    "temperature": {
+        "type": "number",
+        "description": "Sampling temperature",
+        "default": 0.7,
+    },
+    "verbose": {
+        "type": "boolean",
+        "description": "Enable verbose output",
+        "default": False,
+    },
+    "permissions.defaultMode": {
+        "type": "string",
+        "options": ["auto", "plan", "bypass"],
+        "description": "Default permissions mode",
+        "default": "auto",
+    },
+    "tools.enabled": {
+        "type": "array",
+        "items": {"type": "string"},
+        "description": "List of enabled tool names",
+        "default": [],
+    },
+    "tools.disabled": {
+        "type": "array",
+        "items": {"type": "string"},
+        "description": "List of disabled tool names",
+        "default": [],
+    },
 }
 
 
-class ConfigGetTool(BaseTool):
-    """Get a configuration value."""
-
-    name = "config_get"
-    description = "Get configuration value"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "key": {"type": "string", "description": "Config key"}
-        },
-        "required": ["key"]
-    }
-
-    async def execute(self, key: str) -> ToolResult:
-        """Get config value."""
-        data = _load_config()
-        value = data.get("settings", {}).get(key)
-
-        if value is None:
-            value = DEFAULT_SETTINGS.get(key)
-
-        if value is None:
-            return ToolResult(success=False, error=f"Config key not found: {key}")
-
-        return ToolResult(success=True, data={
-            "key": key,
-            "value": value
-        })
-
-
-class ConfigSetTool(BaseTool):
-    """Set a configuration value."""
-
-    name = "config_set"
-    description = "Set configuration value"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "key": {"type": "string", "description": "Config key"},
-            "value": {"type": "string", "description": "Config value"}
-        },
-        "required": ["key", "value"]
-    }
-
-    async def execute(self, key: str, value: Any) -> ToolResult:
-        """Set config value."""
-        data = _load_config()
-
-        if "settings" not in data:
-            data["settings"] = {}
-
-        # Type conversion
-        if value.lower() in ("true", "false"):
-            value = value.lower() == "true"
-        elif value.isdigit():
-            value = int(value)
-        elif value.replace(".", "", 1).isdigit():
-            value = float(value)
-
-        data["settings"][key] = value
-        _save_config(data)
-
-        return ToolResult(success=True, data={
-            "key": key,
-            "value": value,
-            "status": "set"
-        })
-
-
-class ConfigListTool(BaseTool):
-    """List all configuration values."""
-
-    name = "config_list"
-    description = "List all configuration settings"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "include_defaults": {"type": "boolean", "default": False}
-        },
-        "required": []
-    }
-
-    async def execute(self, include_defaults: bool = False) -> ToolResult:
-        """List config."""
-        data = _load_config()
-        settings = data.get("settings", {})
-
-        if include_defaults:
-            all_settings = dict(DEFAULT_SETTINGS)
-            all_settings.update(settings)
-            settings = all_settings
-
-        return ToolResult(success=True, data={
-            "settings": settings,
-            "count": len(settings)
-        })
-
-
-class ConfigDeleteTool(BaseTool):
-    """Delete a configuration value (reset to default)."""
-
-    name = "config_delete"
-    description = "Delete configuration value"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "key": {"type": "string", "description": "Config key to delete"}
-        },
-        "required": ["key"]
-    }
-
-    async def execute(self, key: str) -> ToolResult:
-        """Delete config."""
-        data = _load_config()
-
-        if key in data.get("settings", {}):
-            del data["settings"][key]
-            _save_config(data)
-            return ToolResult(success=True, data={
+class ConfigTool(BaseTool[dict[str, Any], dict[str, Any]]):
+    """Runtime configuration management tool.
+
+    Supports get, set, list, and delete operations on the persistent config store.
+    """
+
+    name = TOOL_NAME
+    description = "Get, set, list, or delete Stack 2.9 runtime configuration settings."
+    search_hint = "get or set configuration settings theme model permissions"
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string",
+                    "enum": ["get", "set", "list", "delete"],
+                    "description": "Configuration operation",
+                },
+                "key": {
+                    "type": "string",
+                    "description": "Configuration key (required for get/set/delete)",
+                },
+                "value": {
+                    "description": "New value (required for 'set' operation)",
+                },
+            },
+            "required": ["operation"],
+        }
+
+    def validate_input(self, input_data: dict[str, Any]) -> tuple[bool, str | None]:
+        op = input_data.get("operation")
+        if op in ("get", "set", "delete") and not input_data.get("key"):
+            return False, f"Error: 'key' is required for '{op}' operation"
+        if op == "set" and "value" not in input_data:
+            return False, "Error: 'value' is required for 'set' operation"
+        return True, None
+
+    def execute(self, input_data: dict[str, Any]) -> ToolResult[dict[str, Any]]:
+        op = input_data.get("operation")
+        key = input_data.get("key")
+        value = input_data.get("value")
+
+        if op == "get":
+            return self._get(key)
+        elif op == "set":
+            return self._set(key, value)
+        elif op == "list":
+            return self._list()
+        elif op == "delete":
+            return self._delete(key)
+        else:
+            return ToolResult(success=False, error=f"Unknown operation: {op}")
+
+    def _get(self, key: str | None) -> ToolResult[dict[str, Any]]:
+        if key is None:
+            return ToolResult(success=False, error="Key is required for 'get'")
+        config = _load_config()
+        current = config.get(key)
+        meta = SUPPORTED_KEYS.get(key, {})
+        return ToolResult(
+            success=True,
+            data={
+                "operation": "get",
+                "key": key,
+                "value": current if current is not None else meta.get("default"),
+                "default": meta.get("default"),
+            },
+        )
+
+    def _set(self, key: str | None, value: Any) -> ToolResult[dict[str, Any]]:
+        if key is None:
+            return ToolResult(success=False, error="Key is required for 'set'")
+
+        meta = SUPPORTED_KEYS.get(key)
+        if meta is not None:
+            expected_type = meta.get("type")
+            # Type coercion
+            if expected_type == "boolean":
+                if isinstance(value, str):
+                    value = value.lower() in ("true", "1", "yes")
+            elif expected_type == "number":
+                try:
+                    value = float(value)
+                except (ValueError, TypeError):
+                    return ToolResult(
+                        success=False,
+                        error=f"Invalid number value for '{key}': {value}",
+                    )
+            # Validate options
+            options = meta.get("options")
+            if options and value not in options:
+                return ToolResult(
+                    success=False,
+                    error=f"Invalid value '{value}' for '{key}'. Options: {', '.join(options)}",
+                )
+
+        config = _load_config()
+        previous = config.get(key)
+        config[key] = value
+        _save_config(config)
+
+        return ToolResult(
+            success=True,
+            data={
+                "operation": "set",
                 "key": key,
-                "status": "deleted"
+                "previousValue": previous,
+                "newValue": value,
+            },
+        )
+
+    def _list(self) -> ToolResult[dict[str, Any]]:
+        config = _load_config()
+        meta = SUPPORTED_KEYS
+
+        items = []
+        all_keys = sorted(set(list(config.keys()) + list(meta.keys())))
+        for k in all_keys:
+            items.append({
+                "key": k,
+                "value": config.get(k, meta.get(k, {}).get("default")),
+                "description": meta.get(k, {}).get("description", ""),
+                "type": meta.get(k, {}).get("type", "unknown"),
+                "options": meta.get(k, {}).get("options"),
+                "is_default": k not in config,
             })
 
-        return ToolResult(success=False, error=f"Config key not found: {key}")
-
-
-# Register tools
-tool_registry.register(ConfigGetTool())
-tool_registry.register(ConfigSetTool())
-tool_registry.register(ConfigListTool())
-tool_registry.register(ConfigDeleteTool())
+        return ToolResult(
+            success=True,
+            data={
+                "operation": "list",
+                "settings": items,
+                "total": len(items),
+            },
+        )
+
+    def _delete(self, key: str | None) -> ToolResult[dict[str, Any]]:
+        if key is None:
+            return ToolResult(success=False, error="Key is required for 'delete'")
+        config = _load_config()
+        if key not in config:
+            return ToolResult(success=False, error=f"Key '{key}' not found in config")
+        previous = config.pop(key)
+        _save_config(config)
+        return ToolResult(
+            success=True,
+            data={
+                "operation": "delete",
+                "key": key,
+                "previousValue": previous,
+            },
+        )
+
+    def map_result_to_message(self, result: dict, tool_use_id: str | None = None) -> str:
+        if not result.get("success", True):
+            return f"Error: {result.get('error')}"
+        data = result.get("data", {})
+        op = data.get("operation", "")
+
+        if op == "get":
+            val = data.get("value")
+            default = data.get("default")
+            note = f" (default: {default})" if default is not None and val == default else ""
+            return f"{data['key']} = {json.dumps(val)}{note}"
+
+        elif op == "set":
+            return f"Set {data['key']} = {json.dumps(data['newValue'])}"
+
+        elif op == "list":
+            settings = data.get("settings", [])
+            if not settings:
+                return "No configuration settings found."
+            lines = [f"{data['total']} setting(s):\n"]
+            for s in settings:
+                val = json.dumps(s["value"])
+                note = f" [{s['type']}]" if s["type"] != "unknown" else ""
+                if s["is_default"]:
+                    note += " (default)"
+                lines.append(f"  {s['key']:30} = {val}{note}")
+            return "\n".join(lines)
+
+        elif op == "delete":
+            return f"Deleted {data['key']} (was: {json.dumps(data['previousValue'])})"
+
+        return str(data)
+
+
+# Auto-register
+get_registry().register(ConfigTool())

src/tools/plan_mode.py

@@ -1,171 +1,261 @@
-"""PlanModeTool - Agent reasoning mode for Stack 2.9"""
-
-import json
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from .base import BaseTool, ToolResult
-from .registry import tool_registry
-
-PLAN_FILE = Path.home() / ".stack-2.9" / "plan.json"
+"""Plan mode tools — EnterPlanMode and ExitPlanMode.
 
+EnterPlanMode switches the agent into a reasoning/planning mode where it
+explores the codebase read-only before writing any code.
 
-def _load_plan() -> Dict[str, Any]:
-    """Load current plan state."""
-    PLAN_FILE.parent.mkdir(parents=True, exist_ok=True)
-    if PLAN_FILE.exists():
-        return json.loads(PLAN_FILE.read_text())
-    return {"active": False, "steps": [], "context": ""}
+ExitPlanMode exits planning mode and returns to normal execution mode.
 
+Plan state is stored in ~/.stack-2.9/plan_mode.json
+Reasoning steps are tracked in ~/.stack-2.9/plan_reasoning.json
+"""
 
-def _save_plan(data: Dict[str, Any]) -> None:
-    """Save plan state."""
-    PLAN_FILE.write_text(json.dumps(data, indent=2))
+from __future__ import annotations
 
+import json
+import os
+from datetime import datetime, timezone
+from typing import Any
 
-def _clear_plan() -> None:
-    """Clear plan state."""
-    if PLAN_FILE.exists():
-        PLAN_FILE.unlink()
-
+from .base import BaseTool, ToolResult
+from .registry import get_registry
+
+DATA_DIR = os.path.expanduser("~/.stack-2.9")
+PLAN_STATE_FILE = os.path.join(DATA_DIR, "plan_mode.json")
+REASONING_FILE = os.path.join(DATA_DIR, "plan_reasoning.json")
+
+
+def _load_plan_state() -> dict[str, Any]:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    if os.path.exists(PLAN_STATE_FILE):
+        try:
+            with open(PLAN_STATE_FILE) as f:
+                return json.load(f)
+        except Exception:
+            pass
+    return {"active": False, "entered_at": None, "plan_text": None, "context": None}
+
+
+def _save_plan_state(state: dict[str, Any]) -> None:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    with open(PLAN_STATE_FILE, "w") as f:
+        json.dump(state, f, indent=2, default=str)
+
+
+def _load_reasoning() -> list[dict[str, Any]]:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    if os.path.exists(REASONING_FILE):
+        try:
+            with open(REASONING_FILE) as f:
+                return json.load(f)
+        except Exception:
+            pass
+    return []
+
+
+def _save_reasoning(steps: list[dict[str, Any]]) -> None:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    with open(REASONING_FILE, "w") as f:
+        json.dump(steps, f, indent=2, default=str)
+
+
+# ── EnterPlanModeTool ───────────────────────────────────────────────────────────
+
+
+class EnterPlanModeTool(BaseTool[dict[str, Any], dict[str, Any]]):
+    """Enter plan mode — a read-only reasoning phase for exploring and designing.
+
+    Parameters
+    ----------
+    plan_text : str, optional
+        Initial plan text to record.
+    context : str, optional
+        Context or task description for the plan.
+    """
+
+    name = "EnterPlanMode"
+    description = (
+        "Switch to plan mode for complex tasks requiring exploration and design. "
+        "In plan mode, you should explore the codebase read-only and design an approach "
+        "before writing any code. Use ExitPlanMode when ready to present your plan."
+    )
+    search_hint = "switch to plan mode to design approach before coding"
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "plan_text": {
+                    "type": "string",
+                    "description": "Initial plan text or summary to record",
+                },
+                "context": {
+                    "type": "string",
+                    "description": "Context or task description guiding the plan",
+                },
+            },
+            "properties": {},
+        }
 
-class EnterPlanModeTool(BaseTool):
-    """Enter plan mode for structured reasoning."""
+    def is_enabled(self) -> bool:
+        state = _load_plan_state()
+        return not state.get("active", False)
 
-    name = "enter_plan_mode"
-    description = "Enter plan mode for structured reasoning"
+    def execute(self, input_data: dict[str, Any]) -> ToolResult[dict[str, Any]]:
+        state = _load_plan_state()
+        if state.get("active"):
+            return ToolResult(success=False, error="Already in plan mode. Use ExitPlanMode first.")
 
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "context": {"type": "string", "description": "Initial context or goal"},
-            "steps": {"type": "array", "items": {"type": "string"}, "description": "Initial reasoning steps"}
-        },
-        "required": ["context"]
-    }
+        now = datetime.now(timezone.utc).isoformat()
+        plan_text = input_data.get("plan_text", "")
+        context = input_data.get("context", "")
 
-    async def execute(self, context: str, steps: Optional[List[str]] = None) -> ToolResult:
-        """Enter plan mode."""
-        data = {
+        new_state = {
             "active": True,
+            "entered_at": now,
+            "plan_text": plan_text,
             "context": context,
-            "steps": steps or [],
-            "entered_at": datetime.now().isoformat(),
-            "last_updated": datetime.now().isoformat()
+            "exited_at": None,
         }
-
-        _save_plan(data)
-
-        return ToolResult(success=True, data={
-            "status": "entered",
+        _save_plan_state(new_state)
+
+        # Initialize reasoning log
+        reasoning = _load_reasoning()
+        reasoning.append({
+            "step": 1,
+            "action": "enter_plan_mode",
+            "timestamp": now,
             "context": context,
-            "step_count": len(steps or [])
+            "note": "Entered plan mode. Begin read-only exploration and design.",
         })
-
-
-class ExitPlanModeTool(BaseTool):
-    """Exit plan mode."""
-
-    name = "exit_plan_mode"
-    description = "Exit plan mode and get summary"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "confirm": {"type": "boolean", "default": False, "description": "Confirm exit"},
-            "summary": {"type": "string", "description": "Optional summary of reasoning"}
-        },
-        "required": ["confirm"]
-    }
-
-    async def execute(self, confirm: bool, summary: Optional[str] = None) -> ToolResult:
-        """Exit plan mode."""
-        if not confirm:
-            return ToolResult(success=False, error="Must confirm exit to leave plan mode")
-
-        data = _load_plan()
-
-        if not data.get("active"):
-            return ToolResult(success=False, error="Plan mode not active")
-
-        result = {
-            "status": "exited",
-            "context": data.get("context"),
-            "step_count": len(data.get("steps", [])),
-            "summary": summary or data.get("context", ""),
-            "duration": datetime.now().isoformat()
+        _save_reasoning(reasoning)
+
+        return ToolResult(
+            success=True,
+            data={
+                "message": "Entered plan mode. Explore the codebase read-only and design your implementation approach.",
+                "plan_text": plan_text,
+                "context": context,
+                "entered_at": now,
+            },
+        )
+
+    def map_result_to_message(self, result: dict, tool_use_id: str | None = None) -> str:
+        data = result.get("data", {})
+        msg = data.get(
+            "message",
+            "Entered plan mode. Explore the codebase read-only and design your approach.",
+        )
+        return f"""{msg}
+
+In plan mode, you should:
+1. Explore the codebase to understand existing patterns
+2. Identify similar features and architectural approaches
+3. Consider multiple approaches and trade-offs
+4. Use FileReadTool to understand the structure
+5. Design a concrete implementation strategy
+6. When ready, use ExitPlanMode to present your plan
+
+DO NOT write or edit any files yet. This is a read-only exploration phase."""
+
+
+# ── ExitPlanModeTool ────────────────────────────────────────────────────────────
+
+
+class ExitPlanModeTool(BaseTool[dict[str, Any], dict[str, Any]]):
+    """Exit plan mode and return to normal execution.
+
+    Parameters
+    ----------
+    confirm : bool, optional
+        Whether the plan is approved (default: True).
+    summary : str, optional
+        A summary or the full plan text to save.
+    """
+
+    name = "ExitPlanMode"
+    description = (
+        "Exit plan mode and return to normal execution. "
+        "Call this when you have finished your plan and are ready to code, "
+        "or to abandon the plan without implementing."
+    )
+    search_hint = "exit plan mode and start coding present plan for approval"
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "confirm": {
+                    "type": "boolean",
+                    "description": "Whether the plan is approved (default: True)",
+                    "default": True,
+                },
+                "summary": {
+                    "type": "string",
+                    "description": "Plan summary or full plan text to save",
+                },
+            },
+            "properties": {},
         }
 
-        _clear_plan()
-
-        return ToolResult(success=True, data=result)
-
-
-class PlanAddStepTool(BaseTool):
-    """Add a reasoning step to the plan."""
-
-    name = "plan_add_step"
-    description = "Add a reasoning step to active plan"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "step": {"type": "string", "description": "Reasoning step text"},
-            "confidence": {"type": "number", "description": "Confidence level 0-1"}
-        },
-        "required": ["step"]
-    }
-
-    async def execute(self, step: str, confidence: Optional[float] = None) -> ToolResult:
-        """Add step to plan."""
-        data = _load_plan()
-
-        if not data.get("active"):
-            return ToolResult(success=False, error="Plan mode not active")
-
-        step_entry = {
-            "text": step,
-            "timestamp": datetime.now().isoformat(),
-            "confidence": confidence
-        }
-
-        data["steps"].append(step_entry)
-        data["last_updated"] = datetime.now().isoformat()
-        _save_plan(data)
-
-        return ToolResult(success=True, data={
-            "step_number": len(data["steps"]),
-            "total_steps": len(data["steps"])
+    def execute(self, input_data: dict[str, Any]) -> ToolResult[dict[str, Any]]:
+        state = _load_plan_state()
+        if not state.get("active"):
+            return ToolResult(success=False, error="Not in plan mode. Use EnterPlanMode first.")
+
+        confirm = input_data.get("confirm", True)
+        summary = input_data.get("summary") or state.get("plan_text", "")
+
+        now = datetime.now(timezone.utc).isoformat()
+
+        # Log exit reasoning step
+        reasoning = _load_reasoning()
+        reasoning.append({
+            "step": len(reasoning) + 1,
+            "action": "exit_plan_mode",
+            "timestamp": now,
+            "confirm": confirm,
+            "summary_length": len(summary) if summary else 0,
+            "note": "Exited plan mode" + (" (plan approved)" if confirm else " (plan rejected/abandoned)"),
         })
+        _save_reasoning(reasoning)
+
+        # Update plan state
+        new_state = {
+            **state,
+            "active": False,
+            "exited_at": now,
+            "plan_text": summary if summary else state.get("plan_text"),
+            "approved": confirm,
+        }
+        _save_plan_state(new_state)
+
+        return ToolResult(
+            success=True,
+            data={
+                "message": "Exited plan mode. Ready to proceed." if confirm else "Plan abandoned.",
+                "plan_text": summary,
+                "confirmed": confirm,
+                "exited_at": now,
+            },
+        )
+
+    def map_result_to_message(self, result: dict, tool_use_id: str | None = None) -> str:
+        data = result.get("data", {})
+        confirm = data.get("confirmed", True)
+        plan_text = data.get("plan_text", "")
+
+        if confirm:
+            lines = ["Plan approved. You can now start coding."]
+            if plan_text:
+                lines.append(f"\nPlan saved:\n{plan_text}")
+            return "\n".join(lines)
+        else:
+            return "Plan abandoned. Exited plan mode."
+
+
+# Auto-register plan mode tools
+get_registry().register(EnterPlanModeTool())
+get_registry().register(ExitPlanModeTool())
 
-
-class PlanStatusTool(BaseTool):
-    """Get current plan status."""
-
-    name = "plan_status"
-    description = "Get status of current plan"
-
-    input_schema = {
-        "type": "object",
-        "properties": {},
-        "required": []
-    }
-
-    async def execute(self) -> ToolResult:
-        """Get plan status."""
-        data = _load_plan()
-
-        return ToolResult(success=True, data={
-            "active": data.get("active", False),
-            "context": data.get("context"),
-            "steps": data.get("steps", []),
-            "step_count": len(data.get("steps", []))
-        })
-
-
-# Register tools
-tool_registry.register(EnterPlanModeTool())
-tool_registry.register(ExitPlanModeTool())
-tool_registry.register(PlanAddStepTool())
-tool_registry.register(PlanStatusTool())

src/tools/registry.py

@@ -51,3 +51,6 @@ class ToolRegistry:
 def get_registry() -> ToolRegistry:
     """Get the global ToolRegistry instance."""
     return ToolRegistry()
+
+# Global registry instance
+tool_registry = ToolRegistry()

src/tools/todo_tool.py

@@ -1,169 +1,184 @@
-"""TodoWriteTool - Persistent todo lists for Stack 2.9"""
+"""TodoWriteTool — persistent todo list management.
 
-import json
-import uuid
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from .base import BaseTool, ToolResult
-from .registry import tool_registry
-
-TODOS_FILE = Path.home() / ".stack-2.9" / "todos.json"
+Stores todos in ~/.stack-2.9/todos.json
 
+Operations:
+  - add    : add a new todo item
+  - complete: mark a todo as completed
+  - delete : remove a todo by id
+  - list   : list all todos (optionally filtered)
 
-def _load_todos() -> Dict[str, Any]:
-    """Load todos from disk."""
-    TODOS_FILE.parent.mkdir(parents=True, exist_ok=True)
-    if TODOS_FILE.exists():
-        return json.loads(TODOS_FILE.read_text())
-    return {"todos": []}
+Input schema:
+  operation : str  — one of add, complete, delete, list
+  task      : str  — description of the task (required for add)
+  todo_id   : str  — id of the todo (required for complete/delete)
+  priority  : str  — low|medium|high|urgent (default: medium, for add)
+"""
 
+from __future__ import annotations
 
-def _save_todos(data: Dict[str, Any]) -> None:
-    """Save todos to disk."""
-    TODOS_FILE.write_text(json.dumps(data, indent=2))
-
-
-class TodoAddTool(BaseTool):
-    """Add a new todo item."""
-
-    name = "todo_add"
-    description = "Add a new todo item"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "task": {"type": "string", "description": "Todo task description"},
-            "priority": {"type": "string", "enum": ["low", "medium", "high"], "default": "medium"},
-            "tags": {"type": "array", "items": {"type": "string"}, "description": "Optional tags"}
-        },
-        "required": ["task"]
-    }
+import json
+import os
+import uuid
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
 
-    async def execute(self, task: str, priority: str = "medium", tags: Optional[List[str]] = None) -> ToolResult:
-        """Add todo."""
-        data = _load_todos()
+from .base import BaseTool, ToolResult
+from .registry import get_registry
+
+TOOL_NAME = "TodoWrite"
+DATA_DIR = os.path.expanduser("~/.stack-2.9")
+TODOS_FILE = os.path.join(DATA_DIR, "todos.json")
+
+
+def _load_todos() -> list[dict[str, Any]]:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    if os.path.exists(TODOS_FILE):
+        try:
+            with open(TODOS_FILE) as f:
+                return json.load(f)
+        except Exception:
+            pass
+    return []
+
+
+def _save_todos(todos: list[dict[str, Any]]) -> None:
+    os.makedirs(DATA_DIR, exist_ok=True)
+    with open(TODOS_FILE, "w") as f:
+        json.dump(todos, f, indent=2, default=str)
+
+
+class TodoWriteTool(BaseTool[dict[str, Any], dict[str, Any]]):
+    """Persistent todo list tool supporting add, complete, delete, and list operations."""
+
+    name = TOOL_NAME
+    description = "Manage a persistent session todo list: add, complete, delete, or list items."
+    search_hint = "manage session todo checklist add complete delete"
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string",
+                    "enum": ["add", "complete", "delete", "list"],
+                    "description": "Operation to perform",
+                },
+                "task": {
+                    "type": "string",
+                    "description": "Task description (required for 'add' operation)",
+                },
+                "todo_id": {
+                    "type": "string",
+                    "description": "Todo ID (required for 'complete' and 'delete' operations)",
+                },
+                "priority": {
+                    "type": "string",
+                    "enum": ["low", "medium", "high", "urgent"],
+                    "description": "Priority level for 'add' operation (default: medium)",
+                    "default": "medium",
+                },
+            },
+            "required": ["operation"],
+        }
 
+    def validate_input(self, input_data: dict[str, Any]) -> tuple[bool, str | None]:
+        op = input_data.get("operation")
+        if op == "add" and not input_data.get("task"):
+            return False, "Error: 'task' is required when adding a todo"
+        if op in ("complete", "delete") and not input_data.get("todo_id"):
+            return False, f"Error: 'todo_id' is required for '{op}' operation"
+        return True, None
+
+    def execute(self, input_data: dict[str, Any]) -> ToolResult[dict[str, Any]]:
+        op = input_data.get("operation")
+        todos = _load_todos()
+
+        if op == "add":
+            return self._add(todos, input_data)
+        elif op == "complete":
+            return self._complete(todos, input_data)
+        elif op == "delete":
+            return self._delete(todos, input_data)
+        elif op == "list":
+            return self._list(todos, input_data)
+        else:
+            return ToolResult(success=False, error=f"Unknown operation: {op}")
+
+    def _add(self, todos: list[dict[str, Any]], input_data: dict[str, Any]) -> ToolResult[dict[str, Any]]:
         todo_id = str(uuid.uuid4())[:8]
-        todo = {
+        now = datetime.now(timezone.utc).isoformat()
+        item = {
             "id": todo_id,
-            "task": task,
-            "priority": priority,
+            "content": input_data["task"],
             "status": "pending",
-            "tags": tags or [],
-            "created_at": datetime.now().isoformat()
+            "priority": input_data.get("priority", "medium"),
+            "created_at": now,
+            "updated_at": now,
         }
-
-        data["todos"].append(todo)
-        _save_todos(data)
-
-        return ToolResult(success=True, data={
-            "id": todo_id,
-            "task": task,
-            "status": "added"
-        })
-
-
-class TodoListTool(BaseTool):
-    """List all todos."""
-
-    name = "todo_list"
-    description = "List all todos with optional filters"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "status": {"type": "string", "enum": ["pending", "completed", "all"], "default": "pending"},
-            "tag": {"type": "string", "description": "Filter by tag"},
-            "priority": {"type": "string", "enum": ["low", "medium", "high"]}
-        },
-        "required": []
-    }
-
-    async def execute(self, status: str = "pending", tag: Optional[str] = None, priority: Optional[str] = None) -> ToolResult:
-        """List todos."""
-        data = _load_todos()
-        todos = data.get("todos", [])
-
-        if status != "all":
-            todos = [t for t in todos if t.get("status") == status]
-
-        if tag:
-            todos = [t for t in todos if tag in t.get("tags", [])]
-
-        if priority:
-            todos = [t for t in todos if t.get("priority") == priority]
-
-        return ToolResult(success=True, data={
-            "todos": todos,
-            "count": len(todos)
-        })
-
-
-class TodoCompleteTool(BaseTool):
-    """Mark a todo as completed."""
-
-    name = "todo_complete"
-    description = "Mark a todo as completed"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "todo_id": {"type": "string", "description": "Todo ID to complete"}
-        },
-        "required": ["todo_id"]
-    }
-
-    async def execute(self, todo_id: str) -> ToolResult:
-        """Complete todo."""
-        data = _load_todos()
-
-        for todo in data["todos"]:
-            if todo["id"] == todo_id:
-                todo["status"] = "completed"
-                todo["completed_at"] = datetime.now().isoformat()
-                _save_todos(data)
-                return ToolResult(success=True, data={
-                    "id": todo_id,
-                    "status": "completed"
-                })
-
-        return ToolResult(success=False, error=f"Todo {todo_id} not found")
-
-
-class TodoDeleteTool(BaseTool):
-    """Delete a todo."""
-
-    name = "todo_delete"
-    description = "Delete a todo item"
-
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "todo_id": {"type": "string", "description": "Todo ID to delete"}
-        },
-        "required": ["todo_id"]
-    }
-
-    async def execute(self, todo_id: str) -> ToolResult:
-        """Delete todo."""
-        data = _load_todos()
-        original_count = len(data["todos"])
-        data["todos"] = [t for t in data["todos"] if t["id"] != todo_id]
-
-        if len(data["todos"]) == original_count:
-            return ToolResult(success=False, error=f"Todo {todo_id} not found")
-
-        _save_todos(data)
-        return ToolResult(success=True, data={
-            "id": todo_id,
-            "status": "deleted"
-        })
-
-
-# Register tools
-tool_registry.register(TodoAddTool())
-tool_registry.register(TodoListTool())
-tool_registry.register(TodoCompleteTool())
-tool_registry.register(TodoDeleteTool())
+        todos.append(item)
+        _save_todos(todos)
+        return ToolResult(
+            success=True,
+            data={"id": todo_id, "content": item["content"], "status": "pending", "priority": item["priority"]},
+        )
+
+    def _complete(self, todos: list[dict[str, Any]], input_data: dict[str, Any]) -> ToolResult[dict[str, Any]]:
+        todo_id = input_data["todo_id"]
+        for t in todos:
+            if t["id"] == todo_id:
+                t["status"] = "completed"
+                t["updated_at"] = datetime.now(timezone.utc).isoformat()
+                _save_todos(todos)
+                return ToolResult(success=True, data={"id": todo_id, "status": "completed"})
+        return ToolResult(success=False, error=f"Todo #{todo_id} not found")
+
+    def _delete(self, todos: list[dict[str, Any]], input_data: dict[str, Any]) -> ToolResult[dict[str, Any]]:
+        todo_id = input_data["todo_id"]
+        original_len = len(todos)
+        todos[:] = [t for t in todos if t["id"] != todo_id]
+        if len(todos) == original_len:
+            return ToolResult(success=False, error=f"Todo #{todo_id} not found")
+        _save_todos(todos)
+        return ToolResult(success=True, data={"id": todo_id, "deleted": True})
+
+    def _list(self, todos: list[dict[str, Any]], input_data: dict[str, Any]) -> ToolResult[dict[str, Any]]:
+        status_filter = input_data.get("status")
+        if status_filter:
+            todos = [t for t in todos if t.get("status") == status_filter]
+        return ToolResult(
+            success=True,
+            data={
+                "todos": todos,
+                "total": len(todos),
+                "pending": sum(1 for t in _load_todos() if t.get("status") == "pending"),
+                "completed": sum(1 for t in _load_todos() if t.get("status") == "completed"),
+            },
+        )
+
+    def map_result_to_message(self, result: dict, tool_use_id: str | None = None) -> str:
+        if "error" in result and not result.get("success", True):
+            return result["error"]
+        data = result.get("data", {})
+        op = data.get("operation", "")
+        if op == "add":
+            return f"Todo #{data['id']} added: {data['content']} [{data['status']}]"
+        elif op == "complete":
+            return f"Todo #{data['id']} marked as completed."
+        elif op == "delete":
+            return f"Todo #{data['id']} deleted."
+        elif op == "list":
+            items = data.get("todos", [])
+            if not items:
+                return "No todos found."
+            lines = [f"{data['total']} todo(s) (pending: {data['pending']}, completed: {data['completed']}):\n"]
+            for t in items:
+                lines.append(f"  [{t['status']:9}] #{t['id']} [{t.get('priority','medium'):6}] {t['content']}")
+            return "\n".join(lines)
+        return str(data)
+
+
+# Auto-register
+get_registry().register(TodoWriteTool())

src/tools/tool_discovery.py

@@ -4,7 +4,7 @@ import json
 from datetime import datetime
 from typing import Any, Dict, List
 
-from .base import ToolResult
+from .base import BaseTool, ToolResult
 from .registry import tool_registry