machinaos 0.0.12 → 0.0.13

package/client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-flow-client",
   "private": true,
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
   "scripts": {
     "start": "vite --host 0.0.0.0",

package/client/src/components/OutputPanel.tsx

@@ -177,9 +177,10 @@ const OutputPanel: React.FC<OutputPanelProps> = ({ nodeId }) => {
   // Helper to check if a handle is a config/auxiliary handle (not main data flow)
   const isConfigHandle = (handle: string | null | undefined): boolean => {
     if (!handle) return false;
-    // Config handles follow pattern: input-<type> where type is not 'main'
+    // Config handles follow pattern: input-<type> where type is not 'main', 'chat', or 'task'
     // Examples: input-memory, input-tools, input-model
-    if (handle.startsWith('input-') && handle !== 'input-main') {
+    // Non-config (data flow) handles: input-main, input-chat, input-task
+    if (handle.startsWith('input-') && handle !== 'input-main' && handle !== 'input-chat' && handle !== 'input-task') {
       return true;
     }
     return false;

package/client/src/components/parameterPanel/InputSection.tsx

@@ -60,10 +60,11 @@ const InputSection: React.FC<InputSectionProps> = ({ nodeId, visible = true }) =
       // Helper to check if a handle is a config/auxiliary handle (not main data flow)
       const isConfigHandle = (handle: string | null | undefined): boolean => {
         if (!handle) return false;
-        // Config handles follow pattern: input-<type> where type is not 'main' or 'chat'
+        // Config handles follow pattern: input-<type> where type is not 'main', 'chat', or 'task'
         // Examples: input-memory, input-tools, input-model, input-skill
-        // Non-config (primary data) handles: input-main, input-chat
-        if (handle.startsWith('input-') && handle !== 'input-main' && handle !== 'input-chat') {
+        // Non-config (primary data) handles: input-main, input-chat, input-task
+        // Note: input-task is for taskTrigger node output which should be visible as draggable variables
+        if (handle.startsWith('input-') && handle !== 'input-main' && handle !== 'input-chat' && handle !== 'input-task') {
           return true;
         }
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "machinaos",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "Open source workflow automation platform with AI agents, React Flow, and n8n-inspired architecture",
   "type": "module",
   "keywords": [

package/server/routers/websocket.py

@@ -629,20 +629,20 @@ async def handle_deploy_workflow(data: Dict[str, Any], websocket: WebSocket) ->
     session_id = data.get("session_id", "default")
 
     # DEBUG: Log received edges to trace tool connection issues
-    logger.info(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")
+    logger.debug(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")
     for e in edges:
         target_handle = e.get('targetHandle')
         if target_handle and target_handle.startswith('input-') and target_handle != 'input-main':
-            logger.info(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")
+            logger.debug(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")
 
     # Check for tool connections to AI Agent
     tool_edges = [e for e in edges if e.get('targetHandle') == 'input-tools']
     if tool_edges:
-        logger.info(f"[Deploy] Tool edges found: {len(tool_edges)}")
+        logger.debug(f"[Deploy] Tool edges found: {len(tool_edges)}")
         for te in tool_edges:
-            logger.info(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")
+            logger.debug(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")
     else:
-        logger.info(f"[Deploy] No input-tools edges found")
+        logger.debug(f"[Deploy] No input-tools edges found")
 
     if not nodes:
         return {"success": False, "error": "No nodes provided"}

package/server/services/ai.py

@@ -2092,6 +2092,7 @@ class AIService:
             'whatsappDb': 'whatsapp_db',
             'gmaps_locations': 'geocode',
             'gmaps_nearby_places': 'nearby_places',
+            'taskManager': 'task_manager',
             'timer': 'timer',
             'cronScheduler': 'cron_scheduler',
             # Built-in check tool for delegation results
@@ -2138,23 +2139,24 @@ class AIService:
             'whatsappDb': 'Query WhatsApp database - list contacts, search groups, get contact/group info, retrieve chat history.',
             'gmaps_locations': 'Geocode addresses to coordinates or reverse geocode coordinates to addresses using Google Maps.',
             'gmaps_nearby_places': 'Search for nearby places (restaurants, hospitals, banks, etc.) using Google Maps Places API.',
+            'taskManager': 'Track delegated sub-agent tasks. Operations: list_tasks (see all tasks), get_task (check specific task status/result), mark_done (cleanup completed tasks).',
             'timer': 'Wait/sleep for a specified duration. Specify duration (1-3600) and unit (seconds, minutes, or hours). Returns timestamp and elapsed time after waiting.',
             'cronScheduler': 'Schedule a delayed or recurring execution. Supports seconds, minutes, hours, daily, weekly, monthly frequencies with timezone. Use frequency to set schedule type, then set the relevant interval/time parameters.',
             # Built-in check tool for delegation results
             '_builtin_check_delegated_tasks': 'Check status and retrieve results of previously delegated tasks.',
-            # Agent delegation tools
-            'aiAgent': 'Delegate a task to another AI Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'chatAgent': 'Delegate a task to a Chat Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'android_agent': 'Delegate to Android Control Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'coding_agent': 'Delegate to Coding Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'web_agent': 'Delegate to Web Control Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'task_agent': 'Delegate to Task Management Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'social_agent': 'Delegate to Social Media Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'travel_agent': 'Delegate to Travel Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'tool_agent': 'Delegate to Tool Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'productivity_agent': 'Delegate to Productivity Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'payments_agent': 'Delegate to Payments Agent. Returns task_id. Use check_delegated_tasks for results.',
-            'consumer_agent': 'Delegate to Consumer Agent. Returns task_id. Use check_delegated_tasks for results.',
+            # Agent delegation tools - ONE-SHOT fire-and-forget pattern
+            'aiAgent': 'ONE-SHOT delegation to AI Agent. Call ONCE per task, returns task_id immediately. Agent works in background - do NOT re-call.',
+            'chatAgent': 'ONE-SHOT delegation to Chat Agent. Call ONCE per task, returns task_id immediately. Agent works in background - do NOT re-call.',
+            'android_agent': 'ONE-SHOT delegation to Android Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'coding_agent': 'ONE-SHOT delegation to Coding Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'web_agent': 'ONE-SHOT delegation to Web Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'task_agent': 'ONE-SHOT delegation to Task Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'social_agent': 'ONE-SHOT delegation to Social Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'travel_agent': 'ONE-SHOT delegation to Travel Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'tool_agent': 'ONE-SHOT delegation to Tool Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'productivity_agent': 'ONE-SHOT delegation to Productivity Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'payments_agent': 'ONE-SHOT delegation to Payments Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
+            'consumer_agent': 'ONE-SHOT delegation to Consumer Agent. Call ONCE per task, returns task_id. Agent works in background - do NOT re-call.',
             # Android service nodes (direct tool usage)
             'batteryMonitor': 'Monitor Android battery status, level, charging state, temperature, and health.',
             'networkMonitor': 'Monitor Android network connectivity, type, and internet availability.',
@@ -2210,6 +2212,29 @@ class AIService:
                 service_names = [s.get('label') or s.get('service_id', 'unknown') for s in connected_services]
                 tool_description = f"{tool_description} Connected: {', '.join(service_names)}"
 
+            # For AI Agent nodes, enhance description with child agent's tool capabilities
+            # This allows parent agent to know what the child agent can do
+            from constants import AI_AGENT_TYPES
+            if node_type in AI_AGENT_TYPES:
+                child_tools = tool_info.get('child_tools', [])
+                if child_tools:
+                    # Build capability description from child's connected tools
+                    capability_descriptions = []
+                    for child_tool in child_tools:
+                        child_type = child_tool.get('node_type', '')
+                        child_label = child_tool.get('label', child_type)
+                        # Get the tool description from DEFAULT_TOOL_DESCRIPTIONS
+                        child_desc = DEFAULT_TOOL_DESCRIPTIONS.get(child_type, f"Use {child_label}")
+                        capability_descriptions.append(f"- {child_label}: {child_desc}")
+
+                    capabilities_text = "\n".join(capability_descriptions)
+                    tool_description = (
+                        f"Delegate tasks to '{node_label}' agent. "
+                        f"This agent has the following capabilities:\n{capabilities_text}\n"
+                        f"Call ONCE per task, returns task_id. Agent works in background."
+                    )
+                    logger.info(f"[LangGraph] Enhanced tool description for {node_type} with {len(child_tools)} child tools")
+
             # Clean tool name (LangChain requires alphanumeric + underscores)
             import re
             tool_name = re.sub(r'[^a-zA-Z0-9_]', '_', tool_name)

package/server/services/deployment/manager.py

@@ -629,6 +629,20 @@ class DeploymentManager:
                 downstream_ids.add(source)
                 logger.debug(f"[Deployment] Including sub-node {source} connected to toolkit {target}")
 
+        # Include tool nodes connected to AI Agent nodes (for capability discovery)
+        # When a child agent is included, we need its connected tools so the parent
+        # can discover what capabilities the child has
+        from constants import AI_AGENT_TYPES
+        agent_node_ids = {n['id'] for n in nodes if n.get('type') in AI_AGENT_TYPES and n['id'] in downstream_ids}
+        for edge in edges:
+            target = edge.get('target')
+            source = edge.get('source')
+            target_handle = edge.get('targetHandle', '')
+            # Include tool nodes connected to agent's input-tools handle
+            if target in agent_node_ids and target_handle == 'input-tools' and source not in downstream_ids:
+                downstream_ids.add(source)
+                logger.debug(f"[Deployment] Including tool node {source} connected to agent {target}")
+
         return [n for n in nodes if n['id'] in downstream_ids]
 
     # =========================================================================

package/server/services/execution/executor.py

@@ -804,6 +804,7 @@ class WorkflowExecutor:
 
         # Build execution context for node handler
         # workflow_id is included for per-workflow status scoping (n8n pattern)
+        logger.info(f"[Executor] Building context for {node.node_id}, ctx.outputs keys: {list(ctx.outputs.keys())}")
         exec_context = {
             "nodes": ctx.nodes,
             "edges": ctx.edges,
@@ -813,6 +814,7 @@ class WorkflowExecutor:
             "start_time": node.started_at,
             "outputs": ctx.outputs,  # Previous node outputs
         }
+        logger.info(f"[Executor] exec_context['outputs'] keys: {list(exec_context['outputs'].keys())}")
 
         # Call the actual node executor
         result = await self.node_executor(

package/server/services/execution/models.py

@@ -13,6 +13,10 @@ from datetime import datetime
 from enum import Enum
 from typing import Dict, Any, List, Optional
 
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
 
 class TaskStatus(str, Enum):
     """Task execution states (Conductor-style lifecycle).
@@ -361,6 +365,8 @@ class ExecutionContext:
             if node.get("_pre_executed"):
                 # Mark as COMPLETED with trigger output
                 trigger_output = node.get("_trigger_output", {})
+                logger.info(f"[ExecutionContext] Pre-executed node found: {node_id} (type={node_type})")
+                logger.info(f"[ExecutionContext] Trigger output keys: {list(trigger_output.keys()) if trigger_output else 'empty'}")
                 node_exec = NodeExecution(
                     node_id=node_id,
                     node_type=node_type,
@@ -369,6 +375,7 @@ class ExecutionContext:
                     completed_at=time.time(),
                 )
                 ctx.outputs[node_id] = trigger_output
+                logger.info(f"[ExecutionContext] Set ctx.outputs[{node_id}] = trigger_output")
                 ctx.checkpoints.append(node_id)
             else:
                 node_exec = NodeExecution(
@@ -378,6 +385,7 @@ class ExecutionContext:
 
             ctx.node_executions[node_id] = node_exec
 
+        logger.info(f"[ExecutionContext] Created context with outputs: {list(ctx.outputs.keys())}")
         return ctx
 
     def get_node_status(self, node_id: str) -> Optional[TaskStatus]:

package/server/services/handlers/ai.py

@@ -203,6 +203,45 @@ async def _collect_agent_connections(
                 tool_entry['connected_services'] = connected_services
                 logger.debug(f"{log_prefix} Android toolkit has {len(connected_services)} connected services")
 
+            # Special handling for AI Agent nodes - discover their connected tools
+            # This allows parent agent to know child agent's capabilities
+            if tool_type in AI_AGENT_TYPES:
+                child_tools = []
+
+                # Count edges targeting this child agent
+                child_incoming_edges = [e for e in edges if e.get('target') == source_node_id]
+                child_tool_edges = [e for e in child_incoming_edges if e.get('targetHandle') == 'input-tools']
+                logger.debug(f"{log_prefix} Child agent {source_node_id}: {len(child_incoming_edges)} incoming edges, {len(child_tool_edges)} input-tools edges")
+
+                # Log all incoming edge handles for debugging
+                if child_incoming_edges:
+                    handles = [e.get('targetHandle', 'None') for e in child_incoming_edges]
+                    logger.debug(f"{log_prefix} Child agent {source_node_id} incoming handles: {handles}")
+
+                # Scan edges for tools connected to this child agent's input-tools handle
+                for child_edge in edges:
+                    if child_edge.get('target') != source_node_id:
+                        continue
+                    if child_edge.get('targetHandle') != 'input-tools':
+                        continue
+
+                    child_tool_id = child_edge.get('source')
+                    child_tool_node = next((n for n in nodes if n.get('id') == child_tool_id), None)
+
+                    logger.debug(f"{log_prefix} Child agent {source_node_id}: tool edge from {child_tool_id}, node found: {child_tool_node is not None}")
+
+                    if child_tool_node:
+                        child_tool_type = child_tool_node.get('type', '')
+                        child_tool_label = child_tool_node.get('data', {}).get('label', child_tool_type)
+                        child_tools.append({
+                            'node_type': child_tool_type,
+                            'label': child_tool_label
+                        })
+
+                if child_tools:
+                    tool_entry['child_tools'] = child_tools
+                    logger.debug(f"{log_prefix} Child agent {source_node_id} has tools: {[t['label'] for t in child_tools]}")
+
             tool_data.append(tool_entry)
             logger.debug(f"{log_prefix} Connected tool: {tool_type}")
 
@@ -218,9 +257,24 @@ async def _collect_agent_connections(
         # Used to receive results from delegated child agents
         elif target_handle == 'input-task':
             logger.info(f"{log_prefix} Found input-task edge from {source_node_id} (type={source_node.get('type')})")
-            all_outputs = context.get('outputs', {})
-            logger.info(f"{log_prefix} Available outputs in context: {list(all_outputs.keys())}")
-            source_output = all_outputs.get(source_node_id)
+
+            # Try context.outputs first (parallel executor), then database via get_output_fn
+            source_output = context.get('outputs', {}).get(source_node_id)
+            logger.info(f"{log_prefix} Context outputs check for {source_node_id}: {source_output is not None}")
+
+            if not source_output:
+                # Database is source of truth - use get_output_fn to retrieve stored output
+                get_output_fn = context.get('get_output_fn')
+                session_id = context.get('session_id', 'default')
+                if get_output_fn:
+                    try:
+                        source_output = await get_output_fn(session_id, source_node_id, 'output_0')
+                        logger.info(f"{log_prefix} DB lookup for {source_node_id}: {source_output is not None}")
+                    except Exception as e:
+                        logger.warning(f"{log_prefix} Failed to get output from DB: {e}")
+                else:
+                    logger.warning(f"{log_prefix} No get_output_fn in context, cannot retrieve task output")
+
             logger.info(f"{log_prefix} Source output for {source_node_id}: {source_output is not None}, type={type(source_output).__name__ if source_output else 'None'}")
             if source_output:
                 # Handle nested result structure - taskTrigger may return {"result": {...}} or flat dict
@@ -320,19 +374,16 @@ async def handle_ai_agent(
         parameters = {**parameters, 'prompt': f"{task_context}\n\n{original_prompt}"}
         logger.info(f"[AI Agent] Task context injected for task_id={task_data.get('task_id')}")
 
-        # CRITICAL FIX: Strip delegation tools when handling task completion
-        # This prevents LLM confusion - tools bound but told not to use them
+        # CRITICAL FIX: Strip ALL tools when handling task completion
+        # When reporting a delegated task result, the agent should NOT use any tools.
+        # Binding tools while instructing "do not use tools" confuses Gemini (returns empty []).
+        # The agent's only job is to report the result naturally.
         task_status = task_data.get('status', '')
         if task_status in ('completed', 'error') and tool_data:
             original_tool_count = len(tool_data)
-            # Filter out AI agent tools (delegation tools)
-            tool_data = [
-                t for t in tool_data
-                if t.get('node_type') not in AI_AGENT_TYPES
-            ]
-            filtered_count = original_tool_count - len(tool_data)
-            if filtered_count > 0:
-                logger.info(f"[AI Agent] Stripped {filtered_count} delegation tools for task completion handling")
+            # Strip ALL tools - agent is just reporting result, not executing anything
+            tool_data = []
+            logger.info(f"[AI Agent] Stripped ALL {original_tool_count} tools for task completion handling")
 
     # Auto-use input data if prompt is empty (fallback for trigger nodes)
     if not parameters.get('prompt') and input_data:
@@ -402,19 +453,16 @@ async def handle_chat_agent(
         parameters = {**parameters, 'prompt': f"{task_context}\n\n{original_prompt}"}
         logger.info(f"[Chat Agent] Task context injected for task_id={task_data.get('task_id')}")
 
-        # CRITICAL FIX: Strip delegation tools when handling task completion
-        # This prevents LLM confusion - tools bound but told not to use them
+        # CRITICAL FIX: Strip ALL tools when handling task completion
+        # When reporting a delegated task result, the agent should NOT use any tools.
+        # Binding tools while instructing "do not use tools" confuses Gemini (returns empty []).
+        # The agent's only job is to report the result naturally.
         task_status = task_data.get('status', '')
         if task_status in ('completed', 'error') and tool_data:
             original_tool_count = len(tool_data)
-            # Filter out AI agent tools (delegation tools)
-            tool_data = [
-                t for t in tool_data
-                if t.get('node_type') not in AI_AGENT_TYPES
-            ]
-            filtered_count = original_tool_count - len(tool_data)
-            if filtered_count > 0:
-                logger.info(f"[Chat Agent] Stripped {filtered_count} delegation tools for task completion handling")
+            # Strip ALL tools - agent is just reporting result, not executing anything
+            tool_data = []
+            logger.info(f"[Chat Agent] Stripped ALL {original_tool_count} tools for task completion handling")
 
     # Auto-use input data if prompt is empty (fallback for trigger nodes)
     if not parameters.get('prompt') and input_data:

package/server/services/handlers/tools.py

@@ -9,7 +9,8 @@ import math
 import json
 import asyncio
 import uuid
-from typing import Dict, Any, Optional, List, TYPE_CHECKING
+import hashlib
+from typing import Dict, Any, Optional, List, Tuple, TYPE_CHECKING
 
 from core.logging import get_logger
 from constants import ANDROID_SERVICE_NODE_TYPES
@@ -27,6 +28,9 @@ _delegated_tasks: Dict[str, asyncio.Task] = {}
 # Follows Celery AsyncResult / Ray ObjectRef pattern
 _delegation_results: Dict[str, Dict[str, Any]] = {}
 
+# Track active delegations to prevent duplicate calls: (parent_node_id, child_node_id, task_hash) -> task_id
+_active_delegations: Dict[Tuple[str, str, str], str] = {}
+
 
 async def execute_tool(tool_name: str, tool_args: Dict[str, Any],
                        config: Dict[str, Any]) -> Dict[str, Any]:
@@ -1171,9 +1175,34 @@ async def _execute_delegated_agent(args: Dict[str, Any],
             "hint": "Ensure nodes/edges are passed to tool config"
         }
 
+    # Get parent node ID for duplicate tracking
+    parent_node_id = config.get('parent_node_id', '')
+
+    # Generate hash of task to detect duplicate delegation attempts
+    task_hash = hashlib.md5(f"{task_description}:{task_context}".encode()).hexdigest()[:16]
+    delegation_key = (parent_node_id, node_id, task_hash)
+
+    # Check for duplicate delegation (prevents LLM from calling same delegation twice)
+    existing_task_id = _active_delegations.get(delegation_key)
+    if existing_task_id:
+        logger.warning(f"[Delegated Agent] Duplicate delegation detected: task_hash={task_hash}, existing_task_id={existing_task_id}")
+        return {
+            "success": True,
+            "status": "ALREADY_DELEGATED",
+            "task_id": existing_task_id,
+            "agent_name": config.get('parameters', {}).get('label', node_type),
+            "result": (
+                f"This task was ALREADY delegated (task_id: {existing_task_id}). "
+                f"Do NOT call this tool again. Use 'check_delegated_tasks' to check status."
+            ),
+        }
+
     # Generate unique task ID
     task_id = f"delegated_{node_id}_{uuid.uuid4().hex[:8]}"
 
+    # Register this delegation to prevent duplicates
+    _active_delegations[delegation_key] = task_id
+
     # Get child agent parameters from database
     child_params = await database.get_node_parameters(node_id) or {}
 
@@ -1246,8 +1275,69 @@ async def _execute_delegated_agent(args: Dict[str, Any],
 
             logger.info(f"[Delegated Agent] Task {task_id} completed: success={result.get('success')}")
 
+            # Check if child agent actually succeeded
+            if not result.get('success'):
+                # Child agent returned failure - treat as error
+                error_msg = result.get('error', 'Child agent returned failure')
+                logger.warning(f"[Delegated Agent] Task {task_id} returned success=False: {error_msg}")
+
+                await broadcaster.update_node_status(
+                    node_id,
+                    "error",
+                    {
+                        "phase": "delegated_error",
+                        "task_id": task_id,
+                        "error": error_msg
+                    },
+                    workflow_id=workflow_id
+                )
+
+                # Cache error for parent retrieval
+                _delegation_results[task_id] = {
+                    "task_id": task_id,
+                    "status": "error",
+                    "agent_name": agent_label,
+                    "agent_node_id": node_id,
+                    "result": None,
+                    "error": error_msg,
+                }
+
+                # Persist error to DB
+                if database:
+                    await database.save_node_output(
+                        node_id=node_id,
+                        session_id=f"delegation_{task_id}",
+                        output_name="delegation_result",
+                        data={
+                            "task_id": task_id,
+                            "parent_node_id": config.get('parent_node_id', ''),
+                            "agent_name": agent_label,
+                            "status": "error",
+                            "error": error_msg,
+                        }
+                    )
+
+                # Dispatch error event for trigger nodes
+                await broadcaster.send_custom_event('task_completed', {
+                    'task_id': task_id,
+                    'status': 'error',
+                    'agent_name': agent_label,
+                    'agent_node_id': node_id,
+                    'parent_node_id': config.get('parent_node_id', ''),
+                    'error': error_msg,
+                    'workflow_id': workflow_id,
+                })
+
+                return result
+
+            # Success case - extract response properly
+            response_text = result.get('result', {}).get('response', '')
+            if not response_text:
+                # Fallback: try to stringify the result dict
+                response_text = str(result.get('result', '')) if result.get('result') else 'No response generated'
+
             # Broadcast completion
-            response_preview = str(result.get('result', {}).get('response', ''))[:200]
+            response_preview = response_text[:200] if response_text else ''
             await broadcaster.update_node_status(
                 node_id,
                 "success",
@@ -1265,7 +1355,7 @@ async def _execute_delegated_agent(args: Dict[str, Any],
                 "status": "completed",
                 "agent_name": agent_label,
                 "agent_node_id": node_id,
-                "result": result.get('result', {}).get('response', str(result.get('result', ''))),
+                "result": response_text,
                 "error": None,
             }
 
@@ -1280,7 +1370,7 @@ async def _execute_delegated_agent(args: Dict[str, Any],
                         "parent_node_id": config.get('parent_node_id', ''),
                         "agent_name": agent_label,
                         "status": "completed",
-                        "result": result.get('result', {}),
+                        "result": response_text,
                     }
                 )
 
@@ -1291,7 +1381,7 @@ async def _execute_delegated_agent(args: Dict[str, Any],
                 'agent_name': agent_label,
                 'agent_node_id': node_id,
                 'parent_node_id': config.get('parent_node_id', ''),
-                'result': result.get('result', {}).get('response', str(result.get('result', ''))),
+                'result': response_text,
                 'workflow_id': workflow_id,
             })
 
@@ -1351,6 +1441,8 @@ async def _execute_delegated_agent(args: Dict[str, Any],
         finally:
             # Cleanup task reference
             _delegated_tasks.pop(task_id, None)
+            # Cleanup delegation tracking (allows re-delegation after completion)
+            _active_delegations.pop(delegation_key, None)
 
     # Spawn as background task (fire-and-forget)
     task = asyncio.create_task(run_child_agent())
@@ -1363,7 +1455,12 @@ async def _execute_delegated_agent(args: Dict[str, Any],
         "task_id": task_id,
         "agent_node_id": node_id,
         "agent_name": agent_label,
-        "message": f"Task delegated to '{agent_label}'. Agent is now working independently on: {task_description[:100]}..."
+        "message": (
+            f"SUCCESS: Task delegated to '{agent_label}' (task_id: {task_id}). "
+            f"Agent is now working INDEPENDENTLY in the background. "
+            f"IMPORTANT: Delegation is COMPLETE. Do NOT call this tool again for this task. "
+            f"To check results later, use 'check_delegated_tasks' with task_id='{task_id}'."
+        ),
     }