feat(tools): introduce plugin-based tool discovery and runtime context protocol

This commit implements a progressive refactoring of the tool system to support
plugin discovery, scoped loading, and protocol-driven runtime context injection.

Key changes:
- Add Tool ABC metadata (tool_name, _scopes) and ToolContext dataclass for
dependency injection.
- Introduce ToolLoader with pkgutil-based builtin discovery and
entry_points-based third-party plugin loading.
- Add scope filtering (core/subagent/memory) so different contexts load
appropriate tool sets.
- Introduce ContextAware protocol and RequestContext dataclass to replace
hardcoded per-tool context injection in AgentLoop.
- Add RuntimeState / MutableRuntimeState protocols to decouple MyTool from
AgentLoop.
- Migrate all built-in tools to declare scopes and implement create()/enabled()
hooks.
- Migrate MessageTool, SpawnTool, CronTool, and MyTool to ContextAware.
- Refactor AgentLoop to use ToolLoader and protocol-driven context injection.
- Refactor SubagentManager to use ToolLoader(scope="subagent") with per-run
FileStates isolation.
- Register all built-in tools via pyproject.toml entry_points.
- Add comprehensive tests for loader scopes, entry_points, ContextAware,
subagent tools, and runtime state sync.

nanobot/agent/tools/message.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Any, Awaitable, Callable
 
 from nanobot.agent.tools.base import Tool, tool_parameters
+from nanobot.agent.tools.context import ContextAware, RequestContext
 from nanobot.agent.tools.schema import ArraySchema, StringSchema, tool_parameters_schema
 from nanobot.bus.events import OutboundMessage
 from nanobot.config.paths import get_workspace_path
@@ -39,7 +40,7 @@ from nanobot.config.paths import get_workspace_path
         required=["content"],
     )
 )
-class MessageTool(Tool):
+class MessageTool(Tool, ContextAware):
     """Tool to send messages to users on chat channels."""
 
     def __init__(
@@ -68,18 +69,18 @@ class MessageTool(Tool):
             default=False,
         )
 
-    def set_context(
-        self,
-        channel: str,
-        chat_id: str,
-        message_id: str | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> None:
+    @classmethod
+    def create(cls, ctx: Any) -> Tool:
+        send_callback = ctx.bus.publish_outbound if ctx.bus else None
+        return cls(send_callback=send_callback, workspace=ctx.workspace)
+
+    def set_context(self, ctx: RequestContext) -> None:
         """Set the current message context."""
-        self._default_channel.set(channel)
-        self._default_chat_id.set(chat_id)
-        self._default_message_id.set(message_id)
-        self._default_metadata.set(metadata or {})
+        self._default_channel.set(ctx.channel)
+        self._default_chat_id.set(ctx.chat_id)
+        self._default_message_id.set(ctx.message_id)
+        if ctx.metadata:
+            self._default_metadata.set(ctx.metadata)
 
     def set_send_callback(self, callback: Callable[[OutboundMessage], Awaitable[None]]) -> None:
         """Set the callback for sending messages."""