Release v1.8.1 — ToolClad, CommunicationPolicyGate, agent lifecycle

New features:
- ToolCladClient: list/validate/test/schema/execute/reload tool manifests
- CommunicationPolicyGate: list/add/remove rules, evaluate communication
- Agent lifecycle: delete_agent, re_execute_agent
- ORGA-adaptive: get_tool_profiles, get_loop_diagnostics
- 6 new Pydantic models for ToolClad and communication types

Author: jaschadub

CHANGELOG.md

@@ -5,6 +5,41 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.8.1] - 2026-03-23
+
+### Added
+
+#### ToolClad Manifest Management
+- **ToolCladClient** — Full client for ToolClad manifest operations via `client.toolclad`
+  - `list_tools()` — List all discovered `.clad.toml` manifests
+  - `validate_manifest()` — Validate a manifest file
+  - `test_tool()` — Dry-run a tool (no execution)
+  - `get_schema()` — Get MCP-compatible JSON schema for a tool
+  - `execute_tool()` — Execute a tool with validated arguments, returns evidence envelope
+  - `get_tool_info()` — Get detailed tool manifest information
+  - `reload_tools()` — Trigger hot-reload of tool manifests
+- **Pydantic models**: `ToolManifestInfo`, `ToolValidationResult`, `ToolTestResult`, `ToolExecutionResult`
+
+#### Inter-Agent Communication Policy Gate
+- `list_communication_rules()` — List all communication policy rules
+- `add_communication_rule()` — Add a policy rule (allow/deny between agents)
+- `remove_communication_rule()` — Remove a rule by ID
+- `evaluate_communication()` — Evaluate whether a communication is allowed
+- **Pydantic models**: `CommunicationRule`, `CommunicationEvaluation`
+
+#### Agent Lifecycle
+- `delete_agent()` — Delete an agent and its metadata
+- `re_execute_agent()` — Re-execute an agent with optional new input (resets ORGA loop)
+
+#### ORGA-Adaptive Features
+- `reasoning.get_tool_profiles()` — Tool execution timing statistics and success rates
+- `reasoning.get_loop_diagnostics()` — Stuck-loop detection, iteration history, adaptive parameters
+
+### Changed
+- Version alignment with Symbiont runtime v1.8.1
+
+---
+
 ## [1.6.1] - 2026-02-28
 
 ### Added

setup.py

@@ -15,7 +15,7 @@ def read_requirements():
 
 setup(
     name='symbiont-sdk',
-    version='1.6.1',
+    version='1.8.1',
     author='Jascha Wanger / ThirdKey.ai',
     author_email='oss@symbiont.dev',
     description='Python SDK for Symbiont platform with Tool Review and Runtime APIs',

symbiont/__init__.py

@@ -34,6 +34,9 @@
     AgentState,
     AgentStatusResponse,
     AnalysisResults,
+    # Communication Policy Models
+    CommunicationEvaluation,
+    CommunicationRule,
     ContextQuery,
     ContextResponse,
     # Agent DSL Models
@@ -82,8 +85,13 @@
     SystemMetrics,
     # Tool Review Models
     Tool,
+    # ToolClad Models
+    ToolExecutionResult,
+    ToolManifestInfo,
     ToolProvider,
     ToolSchema,
+    ToolTestResult,
+    ToolValidationResult,
     VaultAuthMethod,
     VaultConfig,
     VectorMetadata,
@@ -127,6 +135,7 @@
     Usage,
 )
 from .reasoning_client import ReasoningClient
+from .toolclad import ToolCladClient
 from .schedules import (
     CreateScheduleRequest,
     CreateScheduleResponse,
@@ -157,7 +166,7 @@
 # Load environment variables from .env file
 load_dotenv()
 
-__version__ = "1.6.1"
+__version__ = "1.8.1"
 
 __all__ = [
     # Client
@@ -225,6 +234,13 @@
     'MetricsClient', 'MetricsCollector', 'MetricsSnapshot',
     'FileMetricsExporter', 'CompositeExporter',
 
+    # ToolClad
+    'ToolCladClient',
+    'ToolManifestInfo', 'ToolValidationResult', 'ToolTestResult', 'ToolExecutionResult',
+
+    # Communication Policy
+    'CommunicationRule', 'CommunicationEvaluation',
+
     # Reasoning Loop
     'ReasoningClient',
     'Usage', 'ToolDefinition', 'ToolCallRequest',

symbiont/client.py

@@ -155,6 +155,7 @@ def __init__(self,
         self._agentpin: Optional[Any] = None
         self._metrics_client: Optional[Any] = None
         self._reasoning: Optional[Any] = None
+        self._toolclad: Optional[Any] = None
 
     @property
     def schedules(self) -> ScheduleClient:
@@ -194,6 +195,14 @@ def metrics_client(self):
             self._metrics_client = MetricsClient(self)
         return self._metrics_client
 
+    @property
+    def toolclad(self):
+        """Lazy-loaded ToolClad manifest management client."""
+        if self._toolclad is None:
+            from .toolclad import ToolCladClient
+            self._toolclad = ToolCladClient(self)
+        return self._toolclad
+
     def _request(self, method: str, endpoint: str, **kwargs):
         """Make an HTTP request to the API.
 
@@ -1437,3 +1446,93 @@ def disable_http_endpoint(self, endpoint_id: str) -> Dict[str, Any]:
         """
         response = self._request("POST", f"endpoints/{endpoint_id}/disable")
         return response.json()
+
+    # =============================================================================
+    # Inter-Agent Communication Policy Methods
+    # =============================================================================
+
+    def list_communication_rules(self) -> List[Dict]:
+        """List all communication policy rules.
+
+        Returns:
+            List[Dict]: List of communication policy rules
+        """
+        response = self._request("GET", "api/v1/communication/rules")
+        return response.json()
+
+    def add_communication_rule(self, rule: Dict) -> Dict:
+        """Add a communication policy rule.
+
+        Args:
+            rule: Dict with keys: from_agent, to_agent, action (allow/deny),
+                  effect, reason, priority, max_depth
+
+        Returns:
+            Dict: Created rule confirmation
+        """
+        response = self._request("POST", "api/v1/communication/rules", json=rule)
+        return response.json()
+
+    def remove_communication_rule(self, rule_id: str) -> Dict:
+        """Remove a communication policy rule by ID.
+
+        Args:
+            rule_id: The rule identifier
+
+        Returns:
+            Dict: Removal confirmation
+        """
+        response = self._request("DELETE", f"api/v1/communication/rules/{rule_id}")
+        return response.json()
+
+    def evaluate_communication(self, sender: str, recipient: str, action: str) -> Dict:
+        """Evaluate whether a communication is allowed by policy.
+
+        Args:
+            sender: Sending agent identifier
+            recipient: Receiving agent identifier
+            action: The action to evaluate
+
+        Returns:
+            Dict with 'allowed' (bool), 'rule' (matching rule), 'reason'.
+        """
+        response = self._request("POST", "api/v1/communication/evaluate", json={
+            "sender": sender,
+            "recipient": recipient,
+            "action": action,
+        })
+        return response.json()
+
+    # =============================================================================
+    # Agent Lifecycle Methods
+    # =============================================================================
+
+    def delete_agent(self, agent_id: str) -> Dict:
+        """Delete an agent and its metadata.
+
+        Args:
+            agent_id: The agent identifier
+
+        Returns:
+            Dict: Deletion confirmation
+        """
+        response = self._request("DELETE", f"api/v1/agents/{agent_id}")
+        return response.json()
+
+    def re_execute_agent(self, agent_id: str, input_data: Any = None) -> Dict:
+        """Re-execute an agent with optional new input.
+
+        Resets the agent's ORGA loop state and starts a new execution.
+
+        Args:
+            agent_id: The agent identifier
+            input_data: Optional new input data for the agent
+
+        Returns:
+            Dict: Re-execution result
+        """
+        payload = {}
+        if input_data is not None:
+            payload["input"] = input_data
+        response = self._request("POST", f"api/v1/agents/{agent_id}/re-execute", json=payload)
+        return response.json()

symbiont/models.py

@@ -1133,3 +1133,71 @@ class MetricsSnapshot(BaseModel):
     load_balancer: Optional[LoadBalancerMetricsSnapshot] = Field(None, description="Load balancer metrics")
     system: Optional[SystemResourceMetricsSnapshot] = Field(None, description="System resource metrics")
 
+
+# =============================================================================
+# ToolClad Models
+# =============================================================================
+
+class ToolManifestInfo(BaseModel):
+    """Summary of a ToolClad manifest."""
+    name: str
+    version: str
+    description: str
+    risk_tier: str
+    human_approval: bool = False
+    arg_count: int
+    backend: str  # "shell", "http", "mcp", "session", "browser"
+    source_path: str
+
+
+class ToolValidationResult(BaseModel):
+    """Result of manifest validation."""
+    valid: bool
+    errors: List[str] = []
+    warnings: List[str] = []
+
+
+class ToolTestResult(BaseModel):
+    """Result of a tool dry-run."""
+    command: str
+    validations: List[str]
+    cedar: Optional[str] = None
+    timeout: int
+
+
+class ToolExecutionResult(BaseModel):
+    """Evidence envelope from tool execution."""
+    status: str
+    scan_id: str
+    tool: str
+    command: str
+    duration_ms: int
+    timestamp: str
+    output_hash: Optional[str] = None
+    exit_code: int = 0
+    stderr: str = ""
+    results: Dict[str, Any] = {}
+
+
+# =============================================================================
+# Communication Policy Models
+# =============================================================================
+
+class CommunicationRule(BaseModel):
+    """Inter-agent communication policy rule."""
+    id: Optional[str] = None
+    from_agent: str
+    to_agent: str
+    action: str  # "allow" or "deny"
+    effect: str = "allow"
+    reason: str = ""
+    priority: int = 0
+    max_depth: Optional[int] = None
+
+
+class CommunicationEvaluation(BaseModel):
+    """Result of a communication policy evaluation."""
+    allowed: bool
+    rule: Optional[CommunicationRule] = None
+    reason: str = ""
+

symbiont/reasoning_client.py

@@ -184,3 +184,31 @@ def store_knowledge(
                 "confidence": confidence,
             },
         )
+
+    # -------------------------------------------------------------------------
+    # ORGA-Adaptive Features
+    # -------------------------------------------------------------------------
+
+    def get_tool_profiles(self, agent_id: str) -> List[Dict]:
+        """Get tool execution profiles for an agent.
+
+        Returns timing statistics and success rates per tool.
+
+        ``GET /api/v1/agents/{id}/reasoning/tool-profiles``
+        """
+        return self._request(
+            "GET", f"/api/v1/agents/{agent_id}/reasoning/tool-profiles"
+        )
+
+    def get_loop_diagnostics(self, agent_id: str, loop_id: str) -> Dict:
+        """Get diagnostics for a reasoning loop.
+
+        Includes stuck-loop detection status, iteration history,
+        and adaptive parameters.
+
+        ``GET /api/v1/agents/{id}/reasoning/{loop_id}/diagnostics``
+        """
+        return self._request(
+            "GET",
+            f"/api/v1/agents/{agent_id}/reasoning/{loop_id}/diagnostics",
+        )

symbiont/toolclad.py

@@ -0,0 +1,68 @@
+"""ToolClad manifest management client for Symbiont SDK."""
+
+from typing import Any, Dict, List
+
+
+class ToolCladClient:
+    """Client for ToolClad manifest operations.
+
+    This class is typically accessed through the main ``Client`` instance::
+
+        from symbiont import Client
+        client = Client()
+        tools = client.toolclad.list_tools()
+    """
+
+    def __init__(self, client):
+        self._client = client
+
+    def list_tools(self) -> List[Dict[str, Any]]:
+        """List all discovered ToolClad manifests."""
+        response = self._client._request("GET", "api/v1/tools")
+        return response.json()
+
+    def validate_manifest(self, path: str) -> Dict[str, Any]:
+        """Validate a .clad.toml manifest file.
+
+        Args:
+            path: Path to the manifest file (relative to tools_dir)
+        """
+        response = self._client._request(
+            "POST", "api/v1/tools/validate", json={"path": path}
+        )
+        return response.json()
+
+    def test_tool(self, tool_name: str, args: Dict[str, str]) -> Dict[str, Any]:
+        """Dry-run a tool with given arguments (no execution).
+
+        Returns the command that would be executed and validation results.
+        """
+        response = self._client._request(
+            "POST", f"api/v1/tools/{tool_name}/test", json={"args": args}
+        )
+        return response.json()
+
+    def get_schema(self, tool_name: str) -> Dict[str, Any]:
+        """Get the MCP-compatible JSON schema for a tool."""
+        response = self._client._request("GET", f"api/v1/tools/{tool_name}/schema")
+        return response.json()
+
+    def execute_tool(self, tool_name: str, args: Dict[str, str]) -> Dict[str, Any]:
+        """Execute a tool with validated arguments.
+
+        Returns an evidence envelope with results.
+        """
+        response = self._client._request(
+            "POST", f"api/v1/tools/{tool_name}/execute", json={"args": args}
+        )
+        return response.json()
+
+    def get_tool_info(self, tool_name: str) -> Dict[str, Any]:
+        """Get detailed information about a tool manifest."""
+        response = self._client._request("GET", f"api/v1/tools/{tool_name}")
+        return response.json()
+
+    def reload_tools(self) -> Dict[str, Any]:
+        """Trigger a hot-reload of tool manifests from the tools directory."""
+        response = self._client._request("POST", "api/v1/tools/reload")
+        return response.json()