@elizaos/plugin-agent-orchestrator 2.0.0-alpha.3 → 2.0.0-alpha.4

package/dist/index.js

@@ -1,293 +1,556 @@
 // index.ts
 import { getSessionProviders as getSessionProviders2 } from "@elizaos/core";
 
-// src/actions/task-management.ts
-function getService(runtime) {
-  const svc = runtime.getService("CODE_TASK");
-  if (!svc) {
-    throw new Error("AgentOrchestratorService not available (CODE_TASK)");
+// src/actions/messaging.ts
+function extractMessagingParams(message, _state) {
+  const params = message.content?.params;
+  if (!params) {
+    return {};
   }
-  return svc;
-}
-function extractQuery(text) {
-  return text.toLowerCase().replace(/\b(switch|select|go|change|search|find|pause|stop|halt|resume|restart|continue|start|run|begin|cancel|delete|remove|list|show|view)\b/g, "").replace(/\b(about|for|named|called|with|to|my|your|our|this|current)\b/g, "").replace(/\b(task|tasks|the|a|an)\b/g, "").replace(/\s+/g, " ").trim();
+  let target;
+  if (params.target) {
+    target = params.target;
+  } else {
+    target = {};
+    if (params.channel)
+      target.channel = params.channel;
+    if (params.to)
+      target.to = params.to;
+    if (params.threadId !== undefined)
+      target.threadId = params.threadId;
+    if (params.replyTo)
+      target.replyToMessageId = params.replyTo;
+  }
+  let content;
+  if (params.content) {
+    content = params.content;
+  } else {
+    content = {};
+    const text = params.text ?? message.content?.text;
+    if (text)
+      content.text = text;
+  }
+  return { target, content };
 }
-var createTaskAction = {
-  name: "CREATE_TASK",
-  similes: ["START_TASK", "SPAWN_TASK", "NEW_TASK", "BEGIN_TASK"],
-  description: "Create an orchestrated background task to be executed by a selected agent provider.",
-  validate: async (runtime, message) => {
-    const svc = runtime.getService("CODE_TASK");
-    if (!svc) {
+var sendCrossPlatformMessageAction = {
+  name: "SEND_CROSS_PLATFORM_MESSAGE",
+  similes: [
+    "CROSS_PLATFORM_MESSAGE",
+    "UNIFIED_SEND",
+    "SEND_TO_CHANNEL",
+    "RELAY_MESSAGE",
+    "BROADCAST_MESSAGE"
+  ],
+  description: "Send a message to any supported platform (Discord, Telegram, Slack, WhatsApp, Twitch). " + "Requires specifying the target channel/platform and recipient.",
+  validate: async (runtime, message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
       return false;
     }
-    const text = message.content.text?.toLowerCase() ?? "";
-    const hasExplicit = text.includes("create task") || text.includes("new task") || text.includes("start a task");
-    const hasIntent = text.includes("implement") || text.includes("build") || text.includes("create") || text.includes("develop") || text.includes("refactor") || text.includes("fix") || text.includes("add");
-    return hasExplicit || hasIntent;
+    const params = message.content?.params;
+    if (!params) {
+      return true;
+    }
+    const hasTarget = params.target || params.channel && params.to;
+    const hasContent = params.content || params.text || message.content?.text;
+    return !!(hasTarget && hasContent);
   },
-  handler: async (runtime, message, _state, options, callback) => {
-    const svc = getService(runtime);
-    const raw = message.content.text ?? "";
-    const opts = options;
-    const name = (opts?.title ?? raw.split(`
-`)[0] ?? "New Task").trim().slice(0, 100) || "New Task";
-    const description = (opts?.description ?? raw).trim().slice(0, 4000) || name;
-    const roomId = message.roomId;
-    const task = await svc.createTask(name, description, roomId);
-    const stepLines = Array.isArray(opts?.steps) ? opts?.steps : undefined;
-    if (stepLines && stepLines.length > 0) {
-      for (const s of stepLines) {
-        const step = String(s).trim();
-        if (!step)
-          continue;
-        await svc.addStep(task.id ?? "", step);
+  handler: async (runtime, message, state, _options, callback) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available. Please ensure the orchestrator plugin is properly configured."
+        });
       }
-      await svc.appendOutput(task.id ?? "", `Plan:
-${stepLines.map((s, i) => `${i + 1}. ${s}`).join(`
-`)}`);
+      return { success: false, error: "Messaging service not available" };
     }
-    const msg = `Created task: ${task.name}
-Provider: ${task.metadata.providerLabel ?? task.metadata.providerId}
-Starting execution…`;
-    await callback?.({ content: { text: msg } });
-    svc.startTaskExecution(task.id ?? "").catch((err) => {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      svc.appendOutput(task.id ?? "", `Execution error: ${errorMsg}`).catch(() => {});
-    });
-    return { success: true, text: msg, data: { taskId: task.id ?? "" } };
-  }
-};
-var listTasksAction = {
-  name: "LIST_TASKS",
-  similes: ["SHOW_TASKS", "GET_TASKS", "TASKS", "VIEW_TASKS"],
-  description: "List tasks managed by the orchestrator.",
-  validate: async (runtime, message) => {
-    const svc = runtime.getService("CODE_TASK");
-    if (!svc) {
-      return false;
+    const { target, content } = extractMessagingParams(message, state);
+    if (!target?.channel) {
+      if (callback) {
+        await callback({
+          text: "Please specify the target channel (discord, telegram, slack, whatsapp, twitch)."
+        });
+      }
+      return { success: false, error: "Missing target channel" };
     }
-    const t = message.content.text?.toLowerCase() ?? "";
-    return t.includes("list task") || t.includes("show task") || t === "tasks" || t.includes("my task");
-  },
-  handler: async (runtime, _message, _state, _options, callback) => {
-    const svc = getService(runtime);
-    const tasks = await svc.getRecentTasks(20);
-    if (tasks.length === 0) {
-      const msg2 = "No tasks.";
-      await callback?.({ content: { text: msg2 } });
-      return { success: true, text: msg2 };
+    if (!target?.to) {
+      if (callback) {
+        await callback({
+          text: "Please specify the recipient (channel ID, chat ID, or room ID)."
+        });
+      }
+      return { success: false, error: "Missing recipient" };
     }
-    const lines = ["Tasks:"];
-    const current = svc.getCurrentTaskId();
-    for (const t of tasks) {
-      const marker = t.id === current ? " (current)" : "";
-      lines.push(`- ${t.name} — ${t.metadata.status} ${t.metadata.progress}%${marker}`);
+    if (!content?.text) {
+      if (callback) {
+        await callback({
+          text: "Please provide the message text to send."
+        });
+      }
+      return { success: false, error: "Missing message text" };
     }
-    const msg = lines.join(`
-`);
-    await callback?.({ content: { text: msg } });
-    return { success: true, text: msg };
-  }
+    const sendTarget = {
+      channel: target.channel,
+      to: target.to
+    };
+    if (target.threadId !== undefined)
+      sendTarget.threadId = target.threadId;
+    if (target.replyToMessageId)
+      sendTarget.replyToMessageId = target.replyToMessageId;
+    const sendContent = {
+      text: content.text
+    };
+    if (content.attachments)
+      sendContent.attachments = content.attachments;
+    if (content.embed)
+      sendContent.embed = content.embed;
+    if (content.buttons)
+      sendContent.buttons = content.buttons;
+    if (content.disableLinkPreview !== undefined)
+      sendContent.disableLinkPreview = content.disableLinkPreview;
+    if (content.silent !== undefined)
+      sendContent.silent = content.silent;
+    const result = await messagingService.send({
+      target: sendTarget,
+      content: sendContent
+    });
+    if (callback) {
+      if (result.success) {
+        const callbackData = {};
+        if (result.messageId)
+          callbackData.messageId = result.messageId;
+        if (result.sentAt)
+          callbackData.sentAt = result.sentAt;
+        await callback({
+          text: `Message sent successfully to ${target.channel}.`,
+          data: callbackData
+        });
+      } else {
+        await callback({
+          text: `Failed to send message: ${result.error}`
+        });
+      }
+    }
+    return {
+      success: result.success,
+      data: result,
+      ...result.error !== undefined ? { error: result.error } : {}
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send 'Hello from the agent!' to Discord channel 123456789",
+          params: {
+            channel: "discord",
+            to: "123456789",
+            text: "Hello from the agent!"
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message sent successfully to Discord.",
+          actions: ["SEND_CROSS_PLATFORM_MESSAGE"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send a Telegram message",
+          params: {
+            channel: "telegram",
+            to: "-1001234567890",
+            text: "Automated notification from your AI assistant."
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message sent successfully to Telegram.",
+          actions: ["SEND_CROSS_PLATFORM_MESSAGE"]
+        }
+      }
+    ]
+  ]
 };
-var switchTaskAction = {
-  name: "SWITCH_TASK",
-  similes: ["SELECT_TASK", "SET_TASK", "CHANGE_TASK", "GO_TO_TASK"],
-  description: "Switch the current task context to a different task.",
-  validate: async (runtime, message) => {
-    const svc = runtime.getService("CODE_TASK");
-    if (!svc) {
+var sendToDeliveryContextAction = {
+  name: "SEND_TO_DELIVERY_CONTEXT",
+  similes: ["DELIVER_MESSAGE", "SEND_TO_CONTEXT", "ROUTE_MESSAGE"],
+  description: "Send a message using a delivery context that specifies the target channel and recipient. " + "Useful for routing messages back to the original requester or to a specific context.",
+  validate: async (runtime, message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
       return false;
     }
-    const t = message.content.text?.toLowerCase() ?? "";
-    return t.includes("switch to task") || t.includes("select task") || t.includes("task") && t.includes("switch");
+    const params = message.content?.params;
+    if (!params?.deliveryContext) {
+      return false;
+    }
+    const hasText = params.text || message.content?.text;
+    return !!hasText;
   },
   handler: async (runtime, message, _state, _options, callback) => {
-    const svc = getService(runtime);
-    const query = extractQuery(message.content.text ?? "");
-    if (!query) {
-      const msg2 = "Please specify which task to switch to (by name or id).";
-      await callback?.({ content: { text: msg2 } });
-      return { success: false, text: msg2 };
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
     }
-    const matches = await svc.searchTasks(query);
-    const chosen = matches[0];
-    if (!chosen?.id) {
-      const msg2 = `No task found matching: "${query}"`;
-      await callback?.({ content: { text: msg2 } });
-      return { success: false, text: msg2 };
+    const params = message.content?.params;
+    const deliveryContext = params?.deliveryContext;
+    const text = params?.text ?? message.content?.text;
+    if (!deliveryContext) {
+      if (callback) {
+        await callback({
+          text: "Please provide a delivery context with channel and recipient information."
+        });
+      }
+      return { success: false, error: "Missing delivery context" };
     }
-    svc.setCurrentTask(chosen.id);
-    const msg = `Switched to task: ${chosen.name}`;
-    await callback?.({ content: { text: msg } });
-    return { success: true, text: msg, data: { taskId: chosen.id } };
-  }
-};
-var searchTasksAction = {
-  name: "SEARCH_TASKS",
-  similes: ["FIND_TASK", "LOOKUP_TASK"],
-  description: "Search tasks by query.",
-  validate: async (runtime, message) => {
-    const svc = runtime.getService("CODE_TASK");
-    if (!svc) {
-      return false;
-    }
-    const t = message.content.text?.toLowerCase() ?? "";
-    return t.includes("search task") || t.includes("find task") || t.includes("look for task");
-  },
-  handler: async (runtime, message, _state, options, callback) => {
-    const svc = getService(runtime);
-    const opt = options;
-    const query = (opt?.query ?? extractQuery(message.content.text ?? "")).trim();
-    if (!query) {
-      const msg2 = "What would you like to search for?";
-      await callback?.({ content: { text: msg2 } });
-      return { success: false, text: msg2 };
-    }
-    const matches = await svc.searchTasks(query);
-    if (matches.length === 0) {
-      const msg2 = `No tasks found matching: "${query}"`;
-      await callback?.({ content: { text: msg2 } });
-      return { success: true, text: msg2 };
+    if (!text) {
+      if (callback) {
+        await callback({
+          text: "Please provide the message text to send."
+        });
+      }
+      return { success: false, error: "Missing message text" };
     }
-    const lines = [`Found ${matches.length} task(s) matching "${query}":`];
-    for (const t of matches.slice(0, 10)) {
-      lines.push(`- ${t.name} — ${t.metadata.status} ${t.metadata.progress}%`);
+    const result = await messagingService.sendToDeliveryContext(deliveryContext, {
+      text
+    });
+    if (callback) {
+      if (result.success) {
+        const callbackData = {};
+        if (result.messageId)
+          callbackData.messageId = result.messageId;
+        await callback({
+          text: `Message delivered successfully via ${result.channel}.`,
+          data: callbackData
+        });
+      } else {
+        await callback({
+          text: `Failed to deliver message: ${result.error}`
+        });
+      }
     }
-    const msg = lines.join(`
-`);
-    await callback?.({ content: { text: msg } });
-    return { success: true, text: msg };
-  }
+    return {
+      success: result.success,
+      data: result,
+      ...result.error !== undefined ? { error: result.error } : {}
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send result to delivery context",
+          params: {
+            deliveryContext: {
+              channel: "discord",
+              to: "123456789"
+            },
+            text: "Task completed successfully!"
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message delivered successfully via discord.",
+          actions: ["SEND_TO_DELIVERY_CONTEXT"]
+        }
+      }
+    ]
+  ]
 };
-var pauseTaskAction = {
-  name: "PAUSE_TASK",
-  similes: ["STOP_TASK", "HALT_TASK"],
-  description: "Pause a running task.",
-  validate: async (runtime, message) => {
-    const svc = runtime.getService("CODE_TASK");
-    if (!svc) {
+var sendToRoomAction = {
+  name: "SEND_TO_ROOM",
+  similes: ["MESSAGE_ROOM", "ROOM_MESSAGE", "NOTIFY_ROOM"],
+  description: "Send a message to an Eliza room. The room's metadata determines which platform and recipient to use.",
+  validate: async (runtime, message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
       return false;
     }
-    const t = message.content.text?.toLowerCase() ?? "";
-    return (t.includes("pause") || t.includes("stop") || t.includes("halt")) && t.includes("task");
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    const svc = getService(runtime);
-    const query = extractQuery(message.content.text ?? "");
-    const task = query ? (await svc.searchTasks(query))[0] : await svc.getCurrentTask();
-    if (!task?.id) {
-      const msg2 = "No task to pause.";
-      await callback?.({ content: { text: msg2 } });
-      return { success: false, text: msg2 };
-    }
-    await svc.pauseTask(task.id);
-    const msg = `Paused task: ${task.name}`;
-    await callback?.({ content: { text: msg } });
-    return { success: true, text: msg };
-  }
-};
-var resumeTaskAction = {
-  name: "RESUME_TASK",
-  similes: ["CONTINUE_TASK", "RESTART_TASK", "RUN_TASK"],
-  description: "Resume a paused task.",
-  validate: async (runtime, message) => {
-    const svc = runtime.getService("CODE_TASK");
-    if (!svc) {
+    const params = message.content?.params;
+    if (!params?.roomId) {
       return false;
     }
-    const t = message.content.text?.toLowerCase() ?? "";
-    return t.includes("task") && (t.includes("resume") || t.includes("restart") || t.includes("continue"));
+    const hasText = params.text || message.content?.text;
+    return !!hasText;
   },
   handler: async (runtime, message, _state, _options, callback) => {
-    const svc = getService(runtime);
-    const query = extractQuery(message.content.text ?? "");
-    const task = query ? (await svc.searchTasks(query))[0] : await svc.getCurrentTask();
-    if (!task?.id) {
-      const msg2 = "No task to resume.";
-      await callback?.({ content: { text: msg2 } });
-      return { success: false, text: msg2 };
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
     }
-    await svc.resumeTask(task.id);
-    svc.startTaskExecution(task.id).catch((err) => {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      svc.appendOutput(task.id, `Execution error: ${errorMsg}`).catch(() => {});
-    });
-    const msg = `Resumed task: ${task.name}`;
-    await callback?.({ content: { text: msg } });
-    return { success: true, text: msg };
-  }
+    const params = message.content?.params;
+    const roomId = params?.roomId;
+    const text = params?.text ?? message.content?.text;
+    if (!roomId) {
+      if (callback) {
+        await callback({
+          text: "Please specify the room ID to send the message to."
+        });
+      }
+      return { success: false, error: "Missing room ID" };
+    }
+    if (!text) {
+      if (callback) {
+        await callback({
+          text: "Please provide the message text to send."
+        });
+      }
+      return { success: false, error: "Missing message text" };
+    }
+    const result = await messagingService.sendToRoom(roomId, { text });
+    if (callback) {
+      if (result.success) {
+        const callbackData = {};
+        if (result.messageId)
+          callbackData.messageId = result.messageId;
+        await callback({
+          text: `Message sent to room via ${result.channel}.`,
+          data: callbackData
+        });
+      } else {
+        await callback({
+          text: `Failed to send to room: ${result.error}`
+        });
+      }
+    }
+    return {
+      success: result.success,
+      data: result,
+      ...result.error !== undefined ? { error: result.error } : {}
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send to room",
+          params: {
+            roomId: "550e8400-e29b-41d4-a716-446655440000",
+            text: "Hello, room!"
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message sent to room via discord.",
+          actions: ["SEND_TO_ROOM"]
+        }
+      }
+    ]
+  ]
 };
-var cancelTaskAction = {
-  name: "CANCEL_TASK",
-  similes: ["DELETE_TASK", "REMOVE_TASK", "ABORT_TASK"],
-  description: "Cancel a task.",
-  validate: async (runtime, message) => {
-    const svc = runtime.getService("CODE_TASK");
-    if (!svc) {
+var sendToSessionMessageAction = {
+  name: "SEND_TO_SESSION_MESSAGE",
+  similes: ["SESSION_MESSAGE", "MESSAGE_SESSION", "NOTIFY_SESSION"],
+  description: "Send a message to a session by its session key. The session key is mapped to an Eliza room.",
+  validate: async (runtime, message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
       return false;
     }
-    const t = message.content.text?.toLowerCase() ?? "";
-    return (t.includes("cancel") || t.includes("delete") || t.includes("remove")) && t.includes("task");
+    const params = message.content?.params;
+    if (!params?.sessionKey) {
+      return false;
+    }
+    const hasText = params.text || message.content?.text;
+    return !!hasText;
   },
   handler: async (runtime, message, _state, _options, callback) => {
-    const svc = getService(runtime);
-    const query = extractQuery(message.content.text ?? "");
-    const task = query ? (await svc.searchTasks(query))[0] : await svc.getCurrentTask();
-    if (!task?.id) {
-      const msg2 = "No task to cancel.";
-      await callback?.({ content: { text: msg2 } });
-      return { success: false, text: msg2 };
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
     }
-    await svc.cancelTask(task.id);
-    const msg = `Cancelled task: ${task.name}`;
-    await callback?.({ content: { text: msg } });
-    return { success: true, text: msg };
-  }
-};
-
-// src/utils/session.ts
-import crypto from "node:crypto";
-import {
-  buildAgentMainSessionKey,
-  buildAgentSessionKey,
-  buildAgentPeerSessionKey,
-  buildAcpSessionKey,
-  buildSubagentSessionKey,
-  parseAgentSessionKey,
-  isAcpSessionKey,
+    const params = message.content?.params;
+    const sessionKey = params?.sessionKey;
+    const text = params?.text ?? message.content?.text;
+    if (!sessionKey) {
+      if (callback) {
+        await callback({
+          text: "Please specify the session key to send the message to."
+        });
+      }
+      return { success: false, error: "Missing session key" };
+    }
+    if (!text) {
+      if (callback) {
+        await callback({
+          text: "Please provide the message text to send."
+        });
+      }
+      return { success: false, error: "Missing message text" };
+    }
+    const result = await messagingService.sendToSession(sessionKey, { text });
+    if (callback) {
+      if (result.success) {
+        const callbackData = {};
+        if (result.messageId)
+          callbackData.messageId = result.messageId;
+        await callback({
+          text: `Message sent to session via ${result.channel}.`,
+          data: callbackData
+        });
+      } else {
+        await callback({
+          text: `Failed to send to session: ${result.error}`
+        });
+      }
+    }
+    return {
+      success: result.success,
+      data: result,
+      ...result.error !== undefined ? { error: result.error } : {}
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send to session",
+          params: {
+            sessionKey: "agent:main:dm:user123",
+            text: "Update from your subagent!"
+          }
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Message sent to session via discord.",
+          actions: ["SEND_TO_SESSION_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var listMessagingChannelsAction = {
+  name: "LIST_MESSAGING_CHANNELS",
+  similes: ["AVAILABLE_CHANNELS", "GET_CHANNELS", "MESSAGING_PLATFORMS"],
+  description: "List all available messaging channels/platforms that the agent can send messages to.",
+  validate: async (runtime, _message, _state) => {
+    const messagingService = runtime.getService("MESSAGING");
+    return !!messagingService;
+  },
+  handler: async (runtime, _message, _state, _options, callback) => {
+    const messagingService = runtime.getService("MESSAGING");
+    if (!messagingService) {
+      if (callback) {
+        await callback({
+          text: "Messaging service is not available."
+        });
+      }
+      return { success: false, error: "Messaging service not available" };
+    }
+    const channels = messagingService.getAvailableChannels();
+    if (callback) {
+      if (channels.length > 0) {
+        await callback({
+          text: `Available messaging channels: ${channels.join(", ")}`,
+          data: { channels }
+        });
+      } else {
+        await callback({
+          text: "No messaging channels are currently available.",
+          data: { channels: [] }
+        });
+      }
+    }
+    return {
+      success: true,
+      data: { channels }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "What messaging platforms can you use?"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Available messaging channels: discord, telegram, internal",
+          actions: ["LIST_MESSAGING_CHANNELS"]
+        }
+      }
+    ]
+  ]
+};
+
+// src/utils/session.ts
+import crypto from "node:crypto";
+import {
+  buildAcpSessionKey,
+  buildAgentMainSessionKey,
+  buildAgentPeerSessionKey,
+  buildAgentSessionKey,
+  buildGroupHistoryKey,
+  buildSubagentSessionKey,
+  createSendPolicyProvider,
+  createSessionEntry,
+  createSessionProvider,
+  createSessionSkillsProvider,
+  deleteSessionEntry,
+  extractSessionContext,
+  getSessionEntry,
+  getSessionProviders,
+  isAcpSessionKey,
   isSubagentSessionKey,
+  isValidSessionEntry,
+  listSessionKeys,
+  loadSessionStore,
+  mergeSessionEntry,
+  normalizeAccountId,
   normalizeAgentId,
   normalizeMainKey,
-  normalizeAccountId,
-  toAgentRequestSessionKey,
-  toAgentStoreSessionKey,
+  parseAgentSessionKey,
   resolveAgentIdFromSessionKey,
-  resolveThreadParentSessionKey,
-  resolveThreadSessionKeys,
-  buildGroupHistoryKey,
-  loadSessionStore,
-  saveSessionStore,
-  updateSessionStore,
-  updateSessionStoreEntry,
-  getSessionEntry,
-  upsertSessionEntry,
-  deleteSessionEntry,
-  listSessionKeys,
-  resolveStateDir,
   resolveAgentSessionsDir,
   resolveDefaultSessionStorePath,
   resolveSessionTranscriptPath,
+  resolveStateDir,
   resolveStorePath,
-  createSessionProvider,
-  createSessionSkillsProvider,
-  createSendPolicyProvider,
-  getSessionProviders,
-  extractSessionContext,
+  resolveThreadParentSessionKey,
+  resolveThreadSessionKeys,
   SessionStateManager,
-  createSessionEntry,
-  mergeSessionEntry,
-  isValidSessionEntry
+  saveSessionStore,
+  toAgentRequestSessionKey,
+  toAgentStoreSessionKey,
+  updateSessionStore,
+  updateSessionStoreEntry,
+  upsertSessionEntry
 } from "@elizaos/core";
 function hashToUUID(input) {
   const hash = crypto.createHash("sha256").update(input).digest("hex");
@@ -405,25 +668,37 @@ function normalizeDeliveryContext(context) {
   }
   const result = {};
   if (context.channel && typeof context.channel === "string") {
-    result.channel = context.channel.trim() || undefined;
+    const trimmed = context.channel.trim();
+    if (trimmed)
+      result.channel = trimmed;
   }
   if (context.accountId && typeof context.accountId === "string") {
-    result.accountId = context.accountId.trim() || undefined;
+    const trimmed = context.accountId.trim();
+    if (trimmed)
+      result.accountId = trimmed;
   }
   if (context.to && typeof context.to === "string") {
-    result.to = context.to.trim() || undefined;
+    const trimmed = context.to.trim();
+    if (trimmed)
+      result.to = trimmed;
   }
   if (context.threadId !== undefined && context.threadId !== null) {
     result.threadId = context.threadId;
   }
   if (context.groupId && typeof context.groupId === "string") {
-    result.groupId = context.groupId.trim() || undefined;
+    const trimmed = context.groupId.trim();
+    if (trimmed)
+      result.groupId = trimmed;
   }
   if (context.groupChannel && typeof context.groupChannel === "string") {
-    result.groupChannel = context.groupChannel.trim() || undefined;
+    const trimmed = context.groupChannel.trim();
+    if (trimmed)
+      result.groupChannel = trimmed;
   }
   if (context.groupSpace && typeof context.groupSpace === "string") {
-    result.groupSpace = context.groupSpace.trim() || undefined;
+    const trimmed = context.groupSpace.trim();
+    if (trimmed)
+      result.groupSpace = trimmed;
   }
   const hasValues = Object.values(result).some((v) => v !== undefined && v !== null);
   return hasValues ? result : undefined;
@@ -438,15 +713,29 @@ function mergeDeliveryContext(primary, secondary) {
   if (!secondary) {
     return normalizeDeliveryContext(primary);
   }
-  return normalizeDeliveryContext({
-    channel: primary.channel || secondary.channel,
-    accountId: primary.accountId || secondary.accountId,
-    to: primary.to || secondary.to,
-    threadId: primary.threadId ?? secondary.threadId,
-    groupId: primary.groupId || secondary.groupId,
-    groupChannel: primary.groupChannel || secondary.groupChannel,
-    groupSpace: primary.groupSpace || secondary.groupSpace
-  });
+  const merged = {};
+  const ch = primary.channel || secondary.channel;
+  if (ch)
+    merged.channel = ch;
+  const acct = primary.accountId || secondary.accountId;
+  if (acct)
+    merged.accountId = acct;
+  const to = primary.to || secondary.to;
+  if (to)
+    merged.to = to;
+  const tid = primary.threadId ?? secondary.threadId;
+  if (tid !== undefined)
+    merged.threadId = tid;
+  const gid = primary.groupId || secondary.groupId;
+  if (gid)
+    merged.groupId = gid;
+  const gch = primary.groupChannel || secondary.groupChannel;
+  if (gch)
+    merged.groupChannel = gch;
+  const gsp = primary.groupSpace || secondary.groupSpace;
+  if (gsp)
+    merged.groupSpace = gsp;
+  return normalizeDeliveryContext(merged);
 }
 function formatDurationShort(ms) {
   if (!ms || !Number.isFinite(ms) || ms <= 0) {
@@ -485,23 +774,19 @@ function getSubagentService(runtime) {
   }
   return svc;
 }
-function extractSessionContext2(runtime, message) {
+function extractSessionContext2(_runtime, message) {
   const metadata = message.content?.metadata;
   const sessionKey = typeof metadata?.sessionKey === "string" ? metadata.sessionKey : undefined;
-  return {
-    sessionKey,
-    roomId: message.roomId
-  };
+  const result = {};
+  if (sessionKey)
+    result.sessionKey = sessionKey;
+  if (message.roomId)
+    result.roomId = message.roomId;
+  return result;
 }
 var spawnSubagentAction = {
   name: "SPAWN_SUBAGENT",
-  similes: [
-    "SPAWN_TASK",
-    "BACKGROUND_TASK",
-    "START_SUBAGENT",
-    "SESSIONS_SPAWN",
-    "CREATE_SUBAGENT"
-  ],
+  similes: ["SPAWN_TASK", "BACKGROUND_TASK", "START_SUBAGENT", "SESSIONS_SPAWN", "CREATE_SUBAGENT"],
   description: "Spawn a background sub-agent run to execute a task asynchronously. The subagent will complete the task and announce results back.",
   validate: async (runtime, message) => {
     const svc = runtime.getService("SUBAGENT");
@@ -523,18 +808,20 @@ var spawnSubagentAction = {
       await callback?.({ content: { text: msg2 } });
       return { success: false, text: msg2 };
     }
-    const result = await svc.spawnSubagent({
+    const spawnParams = {
       task,
-      label: opts?.label,
-      agentId: opts?.agentId,
-      model: opts?.model,
-      thinking: opts?.thinking,
       runTimeoutSeconds: opts?.timeoutSeconds ?? 300,
       cleanup: opts?.cleanup ?? "keep"
-    }, {
-      sessionKey: context.sessionKey,
-      roomId: context.roomId
-    });
+    };
+    if (opts?.label)
+      spawnParams.label = opts.label;
+    if (opts?.agentId)
+      spawnParams.agentId = opts.agentId;
+    if (opts?.model)
+      spawnParams.model = opts.model;
+    if (opts?.thinking)
+      spawnParams.thinking = opts.thinking;
+    const result = await svc.spawnSubagent(spawnParams, context);
     if (result.status !== "accepted") {
       const msg2 = `Failed to spawn subagent: ${result.error ?? "unknown error"}`;
       await callback?.({ content: { text: msg2 } });
@@ -582,16 +869,17 @@ var sendToSessionAction = {
       await callback?.({ content: { text: msg2 } });
       return { success: false, text: msg2 };
     }
-    const result = await svc.sendToAgent({
-      sessionKey: opts?.sessionKey,
-      label: opts?.label,
-      agentId: opts?.agentId,
+    const sendParams = {
       message: targetMessage,
       timeoutSeconds: opts?.timeoutSeconds ?? 30
-    }, {
-      sessionKey: context.sessionKey,
-      roomId: context.roomId
-    });
+    };
+    if (opts?.sessionKey)
+      sendParams.sessionKey = opts.sessionKey;
+    if (opts?.label)
+      sendParams.label = opts.label;
+    if (opts?.agentId)
+      sendParams.agentId = opts.agentId;
+    const result = await svc.sendToAgent(sendParams, context);
     if (result.status === "forbidden") {
       const msg2 = `Access denied: ${result.error}`;
       await callback?.({ content: { text: msg2 } });
@@ -673,7 +961,7 @@ var cancelSubagentAction = {
     const text = message.content.text?.toLowerCase() ?? "";
     return (text.includes("cancel") || text.includes("stop") || text.includes("abort")) && (text.includes("subagent") || text.includes("background"));
   },
-  handler: async (runtime, message, _state, options, callback) => {
+  handler: async (runtime, _message, _state, options, callback) => {
     const svc = getSubagentService(runtime);
     const opts = options;
     const runId = opts?.runId;
@@ -705,7 +993,7 @@ var getSubagentStatusAction = {
     const text = message.content.text?.toLowerCase() ?? "";
     return text.includes("subagent status") || text.includes("task status") || text.includes("check subagent") || text.includes("subagent info");
   },
-  handler: async (runtime, message, _state, options, callback) => {
+  handler: async (runtime, _message, _state, options, callback) => {
     const svc = getSubagentService(runtime);
     const opts = options;
     const runId = opts?.runId;
@@ -739,491 +1027,250 @@ var getSubagentStatusAction = {
   }
 };
 
-// src/actions/messaging.ts
-function extractMessagingParams(message, state) {
-  const params = message.content?.params;
-  if (!params) {
-    return {};
+// src/actions/task-management.ts
+function getService(runtime) {
+  const svc = runtime.getService("CODE_TASK");
+  if (!svc) {
+    throw new Error("AgentOrchestratorService not available (CODE_TASK)");
   }
-  const target = params.target ?? {
-    channel: params.channel,
-    to: params.to,
-    threadId: params.threadId,
-    replyToMessageId: params.replyTo
-  };
-  const content = params.content ?? {
-    text: params.text ?? message.content?.text
-  };
-  return { target, content };
+  return svc;
 }
-var sendCrossPlatformMessageAction = {
-  name: "SEND_CROSS_PLATFORM_MESSAGE",
-  similes: [
-    "CROSS_PLATFORM_MESSAGE",
-    "UNIFIED_SEND",
-    "SEND_TO_CHANNEL",
-    "RELAY_MESSAGE",
-    "BROADCAST_MESSAGE"
-  ],
-  description: "Send a message to any supported platform (Discord, Telegram, Slack, WhatsApp, Twitch). " + "Requires specifying the target channel/platform and recipient.",
-  validate: async (runtime, message, _state) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
+function extractQuery(text) {
+  return text.toLowerCase().replace(/\b(switch|select|go|change|search|find|pause|stop|halt|resume|restart|continue|start|run|begin|cancel|delete|remove|list|show|view)\b/g, "").replace(/\b(about|for|named|called|with|to|my|your|our|this|current)\b/g, "").replace(/\b(task|tasks|the|a|an)\b/g, "").replace(/\s+/g, " ").trim();
+}
+var createTaskAction = {
+  name: "CREATE_TASK",
+  similes: ["START_TASK", "SPAWN_TASK", "NEW_TASK", "BEGIN_TASK"],
+  description: "Create an orchestrated background task to be executed by a selected agent provider.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
       return false;
     }
-    const params = message.content?.params;
-    if (!params) {
-      return true;
-    }
-    const hasTarget = params.target || params.channel && params.to;
-    const hasContent = params.content || params.text || message.content?.text;
-    return !!(hasTarget && hasContent);
+    const text = message.content.text?.toLowerCase() ?? "";
+    const hasExplicit = text.includes("create task") || text.includes("new task") || text.includes("start a task");
+    const hasIntent = text.includes("implement") || text.includes("build") || text.includes("create") || text.includes("develop") || text.includes("refactor") || text.includes("fix") || text.includes("add");
+    return hasExplicit || hasIntent;
   },
-  handler: async (runtime, message, state, _options, callback) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
-      if (callback) {
-        await callback({
-          text: "Messaging service is not available. Please ensure the orchestrator plugin is properly configured."
-        });
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = getService(runtime);
+    const raw = message.content.text ?? "";
+    const opts = options;
+    const name = (opts?.title ?? raw.split(`
+`)[0] ?? "New Task").trim().slice(0, 100) || "New Task";
+    const description = (opts?.description ?? raw).trim().slice(0, 4000) || name;
+    const roomId = message.roomId;
+    const task = await svc.createTask(name, description, roomId);
+    const stepLines = Array.isArray(opts?.steps) ? opts?.steps : undefined;
+    if (stepLines && stepLines.length > 0) {
+      for (const s of stepLines) {
+        const step = String(s).trim();
+        if (!step)
+          continue;
+        await svc.addStep(task.id ?? "", step);
       }
-      return { success: false, error: "Messaging service not available" };
+      await svc.appendOutput(task.id ?? "", `Plan:
+${stepLines.map((s, i) => `${i + 1}. ${s}`).join(`
+`)}`);
     }
-    const { target, content } = extractMessagingParams(message, state);
-    if (!target?.channel) {
-      if (callback) {
-        await callback({
-          text: "Please specify the target channel (discord, telegram, slack, whatsapp, twitch)."
-        });
-      }
-      return { success: false, error: "Missing target channel" };
-    }
-    if (!target?.to) {
-      if (callback) {
-        await callback({
-          text: "Please specify the recipient (channel ID, chat ID, or room ID)."
-        });
-      }
-      return { success: false, error: "Missing recipient" };
-    }
-    if (!content?.text) {
-      if (callback) {
-        await callback({
-          text: "Please provide the message text to send."
-        });
-      }
-      return { success: false, error: "Missing message text" };
-    }
-    const result = await messagingService.send({
-      target: {
-        channel: target.channel,
-        to: target.to,
-        threadId: target.threadId,
-        replyToMessageId: target.replyToMessageId
-      },
-      content: {
-        text: content.text,
-        attachments: content.attachments,
-        embed: content.embed,
-        buttons: content.buttons,
-        disableLinkPreview: content.disableLinkPreview,
-        silent: content.silent
-      }
+    const msg = `Created task: ${task.name}
+Provider: ${task.metadata.providerLabel ?? task.metadata.providerId}
+Starting execution…`;
+    await callback?.({ content: { text: msg } });
+    svc.startTaskExecution(task.id ?? "").catch((err) => {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      svc.appendOutput(task.id ?? "", `Execution error: ${errorMsg}`).catch(() => {});
     });
-    if (callback) {
-      if (result.success) {
-        await callback({
-          text: `Message sent successfully to ${target.channel}.`,
-          data: { messageId: result.messageId, sentAt: result.sentAt }
-        });
-      } else {
-        await callback({
-          text: `Failed to send message: ${result.error}`
-        });
-      }
+    return { success: true, text: msg, data: { taskId: task.id ?? "" } };
+  }
+};
+var listTasksAction = {
+  name: "LIST_TASKS",
+  similes: ["SHOW_TASKS", "GET_TASKS", "TASKS", "VIEW_TASKS"],
+  description: "List tasks managed by the orchestrator.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
     }
-    return {
-      success: result.success,
-      data: result,
-      error: result.error
-    };
+    const t = message.content.text?.toLowerCase() ?? "";
+    return t.includes("list task") || t.includes("show task") || t === "tasks" || t.includes("my task");
   },
-  examples: [
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "Send 'Hello from the agent!' to Discord channel 123456789",
-          params: {
-            channel: "discord",
-            to: "123456789",
-            text: "Hello from the agent!"
-          }
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "Message sent successfully to Discord.",
-          actions: ["SEND_CROSS_PLATFORM_MESSAGE"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "Send a Telegram message",
-          params: {
-            channel: "telegram",
-            to: "-1001234567890",
-            text: "Automated notification from your AI assistant."
-          }
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "Message sent successfully to Telegram.",
-          actions: ["SEND_CROSS_PLATFORM_MESSAGE"]
-        }
-      }
-    ]
-  ]
+  handler: async (runtime, _message, _state, _options, callback) => {
+    const svc = getService(runtime);
+    const tasks = await svc.getRecentTasks(20);
+    if (tasks.length === 0) {
+      const msg2 = "No tasks.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: true, text: msg2 };
+    }
+    const lines = ["Tasks:"];
+    const current = svc.getCurrentTaskId();
+    for (const t of tasks) {
+      const marker = t.id === current ? " (current)" : "";
+      lines.push(`- ${t.name} — ${t.metadata.status} ${t.metadata.progress}%${marker}`);
+    }
+    const msg = lines.join(`
+`);
+    await callback?.({ content: { text: msg } });
+    return { success: true, text: msg };
+  }
 };
-var sendToDeliveryContextAction = {
-  name: "SEND_TO_DELIVERY_CONTEXT",
-  similes: [
-    "DELIVER_MESSAGE",
-    "SEND_TO_CONTEXT",
-    "ROUTE_MESSAGE"
-  ],
-  description: "Send a message using a delivery context that specifies the target channel and recipient. " + "Useful for routing messages back to the original requester or to a specific context.",
-  validate: async (runtime, message, _state) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
+var switchTaskAction = {
+  name: "SWITCH_TASK",
+  similes: ["SELECT_TASK", "SET_TASK", "CHANGE_TASK", "GO_TO_TASK"],
+  description: "Switch the current task context to a different task.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
       return false;
     }
-    const params = message.content?.params;
-    if (!params?.deliveryContext) {
+    const t = message.content.text?.toLowerCase() ?? "";
+    return t.includes("switch to task") || t.includes("select task") || t.includes("task") && t.includes("switch");
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const svc = getService(runtime);
+    const query = extractQuery(message.content.text ?? "");
+    if (!query) {
+      const msg2 = "Please specify which task to switch to (by name or id).";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    const matches = await svc.searchTasks(query);
+    const chosen = matches[0];
+    if (!chosen?.id) {
+      const msg2 = `No task found matching: "${query}"`;
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
+    }
+    svc.setCurrentTask(chosen.id);
+    const msg = `Switched to task: ${chosen.name}`;
+    await callback?.({ content: { text: msg } });
+    return { success: true, text: msg, data: { taskId: chosen.id } };
+  }
+};
+var searchTasksAction = {
+  name: "SEARCH_TASKS",
+  similes: ["FIND_TASK", "LOOKUP_TASK"],
+  description: "Search tasks by query.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
       return false;
     }
-    const hasText = params.text || message.content?.text;
-    return !!hasText;
+    const t = message.content.text?.toLowerCase() ?? "";
+    return t.includes("search task") || t.includes("find task") || t.includes("look for task");
   },
-  handler: async (runtime, message, state, _options, callback) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
-      if (callback) {
-        await callback({
-          text: "Messaging service is not available."
-        });
-      }
-      return { success: false, error: "Messaging service not available" };
+  handler: async (runtime, message, _state, options, callback) => {
+    const svc = getService(runtime);
+    const opt = options;
+    const query = (opt?.query ?? extractQuery(message.content.text ?? "")).trim();
+    if (!query) {
+      const msg2 = "What would you like to search for?";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
     }
-    const params = message.content?.params;
-    const deliveryContext = params?.deliveryContext;
-    const text = params?.text ?? message.content?.text;
-    if (!deliveryContext) {
-      if (callback) {
-        await callback({
-          text: "Please provide a delivery context with channel and recipient information."
-        });
-      }
-      return { success: false, error: "Missing delivery context" };
+    const matches = await svc.searchTasks(query);
+    if (matches.length === 0) {
+      const msg2 = `No tasks found matching: "${query}"`;
+      await callback?.({ content: { text: msg2 } });
+      return { success: true, text: msg2 };
     }
-    if (!text) {
-      if (callback) {
-        await callback({
-          text: "Please provide the message text to send."
-        });
-      }
-      return { success: false, error: "Missing message text" };
+    const lines = [`Found ${matches.length} task(s) matching "${query}":`];
+    for (const t of matches.slice(0, 10)) {
+      lines.push(`- ${t.name} — ${t.metadata.status} ${t.metadata.progress}%`);
     }
-    const result = await messagingService.sendToDeliveryContext(deliveryContext, {
-      text
-    });
-    if (callback) {
-      if (result.success) {
-        await callback({
-          text: `Message delivered successfully via ${result.channel}.`,
-          data: { messageId: result.messageId }
-        });
-      } else {
-        await callback({
-          text: `Failed to deliver message: ${result.error}`
-        });
-      }
+    const msg = lines.join(`
+`);
+    await callback?.({ content: { text: msg } });
+    return { success: true, text: msg };
+  }
+};
+var pauseTaskAction = {
+  name: "PAUSE_TASK",
+  similes: ["STOP_TASK", "HALT_TASK"],
+  description: "Pause a running task.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
+      return false;
     }
-    return {
-      success: result.success,
-      data: result,
-      error: result.error
-    };
+    const t = message.content.text?.toLowerCase() ?? "";
+    return (t.includes("pause") || t.includes("stop") || t.includes("halt")) && t.includes("task");
   },
-  examples: [
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "Send result to delivery context",
-          params: {
-            deliveryContext: {
-              channel: "discord",
-              to: "123456789"
-            },
-            text: "Task completed successfully!"
-          }
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "Message delivered successfully via discord.",
-          actions: ["SEND_TO_DELIVERY_CONTEXT"]
-        }
-      }
-    ]
-  ]
-};
-var sendToRoomAction = {
-  name: "SEND_TO_ROOM",
-  similes: [
-    "MESSAGE_ROOM",
-    "ROOM_MESSAGE",
-    "NOTIFY_ROOM"
-  ],
-  description: "Send a message to an Eliza room. The room's metadata determines which platform and recipient to use.",
-  validate: async (runtime, message, _state) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
-      return false;
+  handler: async (runtime, message, _state, _options, callback) => {
+    const svc = getService(runtime);
+    const query = extractQuery(message.content.text ?? "");
+    const task = query ? (await svc.searchTasks(query))[0] : await svc.getCurrentTask();
+    if (!task?.id) {
+      const msg2 = "No task to pause.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
     }
-    const params = message.content?.params;
-    if (!params?.roomId) {
+    await svc.pauseTask(task.id);
+    const msg = `Paused task: ${task.name}`;
+    await callback?.({ content: { text: msg } });
+    return { success: true, text: msg };
+  }
+};
+var resumeTaskAction = {
+  name: "RESUME_TASK",
+  similes: ["CONTINUE_TASK", "RESTART_TASK", "RUN_TASK"],
+  description: "Resume a paused task.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
       return false;
     }
-    const hasText = params.text || message.content?.text;
-    return !!hasText;
+    const t = message.content.text?.toLowerCase() ?? "";
+    return t.includes("task") && (t.includes("resume") || t.includes("restart") || t.includes("continue"));
   },
-  handler: async (runtime, message, state, _options, callback) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
-      if (callback) {
-        await callback({
-          text: "Messaging service is not available."
-        });
-      }
-      return { success: false, error: "Messaging service not available" };
-    }
-    const params = message.content?.params;
-    const roomId = params?.roomId;
-    const text = params?.text ?? message.content?.text;
-    if (!roomId) {
-      if (callback) {
-        await callback({
-          text: "Please specify the room ID to send the message to."
-        });
-      }
-      return { success: false, error: "Missing room ID" };
-    }
-    if (!text) {
-      if (callback) {
-        await callback({
-          text: "Please provide the message text to send."
-        });
-      }
-      return { success: false, error: "Missing message text" };
-    }
-    const result = await messagingService.sendToRoom(roomId, { text });
-    if (callback) {
-      if (result.success) {
-        await callback({
-          text: `Message sent to room via ${result.channel}.`,
-          data: { messageId: result.messageId }
-        });
-      } else {
-        await callback({
-          text: `Failed to send to room: ${result.error}`
-        });
-      }
+  handler: async (runtime, message, _state, _options, callback) => {
+    const svc = getService(runtime);
+    const query = extractQuery(message.content.text ?? "");
+    const task = query ? (await svc.searchTasks(query))[0] : await svc.getCurrentTask();
+    if (!task?.id) {
+      const msg2 = "No task to resume.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
     }
-    return {
-      success: result.success,
-      data: result,
-      error: result.error
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "Send to room",
-          params: {
-            roomId: "550e8400-e29b-41d4-a716-446655440000",
-            text: "Hello, room!"
-          }
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "Message sent to room via discord.",
-          actions: ["SEND_TO_ROOM"]
-        }
-      }
-    ]
-  ]
+    await svc.resumeTask(task.id);
+    const taskId = task.id;
+    svc.startTaskExecution(taskId).catch((err) => {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      svc.appendOutput(taskId, `Execution error: ${errorMsg}`).catch(() => {});
+    });
+    const msg = `Resumed task: ${task.name}`;
+    await callback?.({ content: { text: msg } });
+    return { success: true, text: msg };
+  }
 };
-var sendToSessionMessageAction = {
-  name: "SEND_TO_SESSION_MESSAGE",
-  similes: [
-    "SESSION_MESSAGE",
-    "MESSAGE_SESSION",
-    "NOTIFY_SESSION"
-  ],
-  description: "Send a message to a session by its session key. The session key is mapped to an Eliza room.",
-  validate: async (runtime, message, _state) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
-      return false;
-    }
-    const params = message.content?.params;
-    if (!params?.sessionKey) {
+var cancelTaskAction = {
+  name: "CANCEL_TASK",
+  similes: ["DELETE_TASK", "REMOVE_TASK", "ABORT_TASK"],
+  description: "Cancel a task.",
+  validate: async (runtime, message) => {
+    const svc = runtime.getService("CODE_TASK");
+    if (!svc) {
       return false;
     }
-    const hasText = params.text || message.content?.text;
-    return !!hasText;
+    const t = message.content.text?.toLowerCase() ?? "";
+    return (t.includes("cancel") || t.includes("delete") || t.includes("remove")) && t.includes("task");
   },
-  handler: async (runtime, message, state, _options, callback) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
-      if (callback) {
-        await callback({
-          text: "Messaging service is not available."
-        });
-      }
-      return { success: false, error: "Messaging service not available" };
-    }
-    const params = message.content?.params;
-    const sessionKey = params?.sessionKey;
-    const text = params?.text ?? message.content?.text;
-    if (!sessionKey) {
-      if (callback) {
-        await callback({
-          text: "Please specify the session key to send the message to."
-        });
-      }
-      return { success: false, error: "Missing session key" };
-    }
-    if (!text) {
-      if (callback) {
-        await callback({
-          text: "Please provide the message text to send."
-        });
-      }
-      return { success: false, error: "Missing message text" };
-    }
-    const result = await messagingService.sendToSession(sessionKey, { text });
-    if (callback) {
-      if (result.success) {
-        await callback({
-          text: `Message sent to session via ${result.channel}.`,
-          data: { messageId: result.messageId }
-        });
-      } else {
-        await callback({
-          text: `Failed to send to session: ${result.error}`
-        });
-      }
+  handler: async (runtime, message, _state, _options, callback) => {
+    const svc = getService(runtime);
+    const query = extractQuery(message.content.text ?? "");
+    const task = query ? (await svc.searchTasks(query))[0] : await svc.getCurrentTask();
+    if (!task?.id) {
+      const msg2 = "No task to cancel.";
+      await callback?.({ content: { text: msg2 } });
+      return { success: false, text: msg2 };
     }
-    return {
-      success: result.success,
-      data: result,
-      error: result.error
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "Send to session",
-          params: {
-            sessionKey: "agent:main:dm:user123",
-            text: "Update from your subagent!"
-          }
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "Message sent to session via discord.",
-          actions: ["SEND_TO_SESSION_MESSAGE"]
-        }
-      }
-    ]
-  ]
-};
-var listMessagingChannelsAction = {
-  name: "LIST_MESSAGING_CHANNELS",
-  similes: [
-    "AVAILABLE_CHANNELS",
-    "GET_CHANNELS",
-    "MESSAGING_PLATFORMS"
-  ],
-  description: "List all available messaging channels/platforms that the agent can send messages to.",
-  validate: async (runtime, _message, _state) => {
-    const messagingService = runtime.getService("MESSAGING");
-    return !!messagingService;
-  },
-  handler: async (runtime, _message, _state, _options, callback) => {
-    const messagingService = runtime.getService("MESSAGING");
-    if (!messagingService) {
-      if (callback) {
-        await callback({
-          text: "Messaging service is not available."
-        });
-      }
-      return { success: false, error: "Messaging service not available" };
-    }
-    const channels = messagingService.getAvailableChannels();
-    if (callback) {
-      if (channels.length > 0) {
-        await callback({
-          text: `Available messaging channels: ${channels.join(", ")}`,
-          data: { channels }
-        });
-      } else {
-        await callback({
-          text: "No messaging channels are currently available.",
-          data: { channels: [] }
-        });
-      }
-    }
-    return {
-      success: true,
-      data: { channels }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "What messaging platforms can you use?"
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "Available messaging channels: discord, telegram, internal",
-          actions: ["LIST_MESSAGING_CHANNELS"]
-        }
-      }
-    ]
-  ]
+    await svc.cancelTask(task.id);
+    const msg = `Cancelled task: ${task.name}`;
+    await callback?.({ content: { text: msg } });
+    return { success: true, text: msg };
+  }
 };
 
 // src/config.ts
@@ -1235,61 +1282,6 @@ function getConfiguredAgentOrchestratorOptions() {
   return globalOptions;
 }
 
-// src/providers/task-context.ts
-function getService2(runtime) {
-  return runtime.getService("CODE_TASK");
-}
-function formatStatus(status) {
-  switch (status) {
-    case "pending":
-      return "⏳ pending";
-    case "running":
-      return "\uD83D\uDD04 running";
-    case "paused":
-      return "⏸️ paused";
-    case "completed":
-      return "✅ completed";
-    case "failed":
-      return "❌ failed";
-    case "cancelled":
-      return "\uD83D\uDED1 cancelled";
-    default:
-      return status;
-  }
-}
-var taskContextProvider = {
-  name: "TASK_CONTEXT",
-  description: "Summary of orchestrated tasks and current selection",
-  dynamic: true,
-  get: async (runtime, _message, _state) => {
-    const svc = getService2(runtime);
-    if (!svc) {
-      return { text: "Task service not available." };
-    }
-    const current = await svc.getCurrentTask();
-    const tasks = await svc.getRecentTasks(10);
-    if (tasks.length === 0) {
-      return { text: "No tasks have been created yet." };
-    }
-    const lines = [];
-    if (current) {
-      lines.push(`## Current Task`);
-      lines.push(`- Name: ${current.name}`);
-      lines.push(`- Status: ${formatStatus(current.metadata.status)}`);
-      lines.push(`- Progress: ${current.metadata.progress}%`);
-      lines.push(`- Provider: ${current.metadata.providerLabel ?? current.metadata.providerId}`);
-      lines.push("");
-    }
-    lines.push("## Recent Tasks");
-    for (const t of tasks) {
-      const marker = current?.id === t.id ? " (current)" : "";
-      lines.push(`- ${t.name} — ${formatStatus(t.metadata.status)} ${t.metadata.progress}%${marker}`);
-    }
-    return { text: lines.join(`
-`).trim() };
-  }
-};
-
 // src/providers/orchestrator-config.ts
 var DEFAULT_CONFIG = {
   subagents: {
@@ -1316,15 +1308,18 @@ function getOrchestratorConfig(runtime) {
   const subagentsRaw = settings.subagents ?? {};
   const a2aRaw = settings.agentToAgent ?? {};
   const sandboxRaw = settings.sandbox ?? {};
+  const subagents = {
+    enabled: subagentsRaw.enabled ?? true,
+    timeoutSeconds: subagentsRaw.timeoutSeconds ?? 300,
+    allowAgents: subagentsRaw.allowAgents ?? [],
+    archiveAfterMinutes: subagentsRaw.archiveAfterMinutes ?? 60
+  };
+  if (subagentsRaw.model)
+    subagents.model = subagentsRaw.model;
+  if (subagentsRaw.thinking)
+    subagents.thinking = subagentsRaw.thinking;
   return {
-    subagents: {
-      enabled: subagentsRaw.enabled ?? DEFAULT_CONFIG.subagents.enabled,
-      model: subagentsRaw.model,
-      thinking: subagentsRaw.thinking,
-      timeoutSeconds: subagentsRaw.timeoutSeconds ?? DEFAULT_CONFIG.subagents.timeoutSeconds,
-      allowAgents: subagentsRaw.allowAgents ?? DEFAULT_CONFIG.subagents.allowAgents,
-      archiveAfterMinutes: subagentsRaw.archiveAfterMinutes ?? DEFAULT_CONFIG.subagents.archiveAfterMinutes
-    },
+    subagents,
     agentToAgent: {
       enabled: a2aRaw.enabled ?? DEFAULT_CONFIG.agentToAgent.enabled,
       allow: a2aRaw.allow ?? DEFAULT_CONFIG.agentToAgent.allow
@@ -1373,7 +1368,62 @@ var orchestratorConfigProvider = {
   description: "Provides orchestrator configuration including subagents, A2A, and sandbox settings",
   get: async (runtime, _message, _state) => {
     const config = getOrchestratorConfig(runtime);
-    return formatConfigContext(config);
+    return { text: formatConfigContext(config) };
+  }
+};
+
+// src/providers/task-context.ts
+function getService2(runtime) {
+  return runtime.getService("CODE_TASK");
+}
+function formatStatus(status) {
+  switch (status) {
+    case "pending":
+      return "⏳ pending";
+    case "running":
+      return "\uD83D\uDD04 running";
+    case "paused":
+      return "⏸️ paused";
+    case "completed":
+      return "✅ completed";
+    case "failed":
+      return "❌ failed";
+    case "cancelled":
+      return "\uD83D\uDED1 cancelled";
+    default:
+      return status;
+  }
+}
+var taskContextProvider = {
+  name: "TASK_CONTEXT",
+  description: "Summary of orchestrated tasks and current selection",
+  dynamic: true,
+  get: async (runtime, _message, _state) => {
+    const svc = getService2(runtime);
+    if (!svc) {
+      return { text: "Task service not available." };
+    }
+    const current = await svc.getCurrentTask();
+    const tasks = await svc.getRecentTasks(10);
+    if (tasks.length === 0) {
+      return { text: "No tasks have been created yet." };
+    }
+    const lines = [];
+    if (current) {
+      lines.push(`## Current Task`);
+      lines.push(`- Name: ${current.name}`);
+      lines.push(`- Status: ${formatStatus(current.metadata.status)}`);
+      lines.push(`- Progress: ${current.metadata.progress}%`);
+      lines.push(`- Provider: ${current.metadata.providerLabel ?? current.metadata.providerId}`);
+      lines.push("");
+    }
+    lines.push("## Recent Tasks");
+    for (const t of tasks) {
+      const marker = current?.id === t.id ? " (current)" : "";
+      lines.push(`- ${t.name} — ${formatStatus(t.metadata.status)} ${t.metadata.progress}%${marker}`);
+    }
+    return { text: lines.join(`
+`).trim() };
   }
 };
 
@@ -1809,694 +1859,584 @@ Provider: ${provider.label} (${provider.id})`);
       const roomId = task.roomId ?? undefined;
       const worldId = task.worldId ?? undefined;
       const execCtxBase = {
-        runtimeAgentId: this.runtime.agentId,
-        workingDirectory: task.metadata.workingDirectory,
-        appendOutput: async (line) => this.appendOutput(taskId, line),
-        updateProgress: async (p) => this.updateTaskProgress(taskId, p),
-        updateStep: async (stepId, status, output) => this.updateStep(taskId, stepId, status, output),
-        isCancelled: () => this.isTaskCancelled(taskId),
-        isPaused: () => this.isTaskPaused(taskId)
-      };
-      const execCtx = {
-        ...execCtxBase,
-        ...roomId ? { roomId } : {},
-        ...worldId ? { worldId } : {}
-      };
-      const result = await provider.executeTask(task, execCtx);
-      await this.setTaskResult(taskId, result);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      await this.setTaskError(taskId, msg);
-    } finally {
-      this.clearControl(taskId);
-    }
-  }
-  on(event, handler) {
-    this.emitter.on(event, handler);
-  }
-  off(event, handler) {
-    this.emitter.off(event, handler);
-  }
-  emit(type, taskId, data) {
-    const event = data ? { type, taskId, data } : { type, taskId };
-    this.emitter.emit(type, event);
-    this.emitter.emit("task", event);
-  }
-  async stop() {
-    this.emitter.removeAllListeners();
-    this.controlStates.clear();
-    this.executions.clear();
-  }
-  async getTaskContext() {
-    const current = await this.getCurrentTask();
-    const tasks = await this.getRecentTasks(10);
-    if (tasks.length === 0) {
-      return "No tasks have been created yet.";
-    }
-    const lines = [];
-    const active = current ?? tasks[0] ?? null;
-    if (active) {
-      const m = active.metadata;
-      lines.push(`## Current Task (selected): ${active.name}`);
-      lines.push(`- **Execution status**: ${m.status}`);
-      lines.push(`- **Progress**: ${m.progress}%`);
-      lines.push(`- **Provider**: ${m.providerLabel ?? m.providerId}`);
-      lines.push("");
-      if (active.description) {
-        lines.push("### Description");
-        lines.push(active.description);
-        lines.push("");
-      }
-      if (m.steps.length > 0) {
-        lines.push("### Plan / Steps");
-        for (const s of m.steps) {
-          lines.push(`- [${s.status}] ${s.description}`);
-        }
-        lines.push("");
-      }
-      if (m.output.length > 0) {
-        lines.push("### Task Output (history)");
-        lines.push("```");
-        lines.push(...m.output.slice(-200));
-        lines.push("```");
-        lines.push("");
-      }
-    }
-    return lines.join(`
-`).trim();
-  }
-}
-
-// src/services/subagent-service.ts
-import { EventEmitter as EventEmitter2 } from "node:events";
-import crypto2 from "node:crypto";
-import {
-  EventType,
-  ChannelType,
-  Service as Service2
-} from "@elizaos/core";
-class SubagentService extends Service2 {
-  static serviceType = "SUBAGENT";
-  capabilityDescription = "Manages subagent spawning, lifecycle, and communication";
-  emitter = new EventEmitter2;
-  subagentRuns = new Map;
-  activeRuns = new Map;
-  sweeper = null;
-  initialized = false;
-  static async start(runtime) {
-    const service = new SubagentService(runtime);
-    await service.initialize();
-    return service;
-  }
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-    this.initialized = true;
-    this.runtime.registerEvent(EventType.RUN_ENDED, async (payload) => {
-      await this.handleRunEnded(payload);
-    });
-    this.runtime.registerEvent(EventType.RUN_TIMEOUT, async (payload) => {
-      await this.handleRunTimeout(payload);
-    });
-    this.startSweeper();
-  }
-  getConfig() {
-    const settings = this.runtime.character?.settings;
-    const subagents = settings?.subagents ?? {};
-    return {
-      enabled: subagents.enabled !== false,
-      model: subagents.model,
-      thinking: subagents.thinking,
-      timeoutSeconds: subagents.timeoutSeconds ?? 300,
-      allowAgents: subagents.allowAgents ?? [],
-      archiveAfterMinutes: subagents.archiveAfterMinutes ?? 60
-    };
-  }
-  getAgentToAgentPolicy() {
-    const settings = this.runtime.character?.settings;
-    const a2aConfig = settings?.agentToAgent ?? {};
-    const enabled = a2aConfig.enabled === true;
-    const allowRules = (a2aConfig.allow ?? []).map((rule) => ({
-      source: rule.source ?? "*",
-      target: rule.target ?? "*"
-    }));
-    return {
-      enabled,
-      allowRules,
-      isAllowed: (sourceAgentId, targetAgentId) => {
-        if (!enabled) {
-          return false;
-        }
-        if (sourceAgentId === targetAgentId) {
-          return true;
-        }
-        const sourceNorm = normalizeAgentId2(sourceAgentId);
-        const targetNorm = normalizeAgentId2(targetAgentId);
-        for (const rule of allowRules) {
-          const sourceMatch = rule.source === "*" || normalizeAgentId2(rule.source) === sourceNorm;
-          const targetMatch = rule.target === "*" || normalizeAgentId2(rule.target) === targetNorm;
-          if (sourceMatch && targetMatch) {
-            return true;
-          }
-        }
-        return false;
-      }
-    };
-  }
-  async spawnSubagent(params, requesterContext) {
-    const config = this.getConfig();
-    if (!config.enabled) {
-      return {
-        status: "forbidden",
-        error: "Subagent spawning is disabled"
-      };
-    }
-    if (requesterContext.sessionKey && isSubagentSessionKey2(requesterContext.sessionKey)) {
-      return {
-        status: "forbidden",
-        error: "sessions_spawn is not allowed from sub-agent sessions"
-      };
-    }
-    const requesterAgentId = requesterContext.sessionKey ? extractAgentIdFromSessionKey(requesterContext.sessionKey) : this.runtime.character?.name ?? "unknown";
-    const targetAgentId = params.agentId ? normalizeAgentId2(params.agentId) : requesterAgentId;
-    if (targetAgentId !== requesterAgentId) {
-      const allowAgents = config.allowAgents ?? [];
-      const allowAny = allowAgents.some((v) => v.trim() === "*");
-      const allowSet = new Set(allowAgents.filter((v) => v.trim() && v.trim() !== "*").map((v) => normalizeAgentId2(v)));
-      if (!allowAny && !allowSet.has(targetAgentId)) {
-        return {
-          status: "forbidden",
-          error: `agentId "${targetAgentId}" is not allowed for subagent spawning`
-        };
-      }
-    }
-    const childSessionKey = createSubagentSessionKey(targetAgentId);
-    const runId = crypto2.randomUUID();
-    const childRoomId = sessionKeyToRoomId(childSessionKey, targetAgentId);
-    const roomMetadata = {
-      isSubagent: true,
-      sessionKey: childSessionKey,
-      parentRoomId: requesterContext.roomId,
-      parentSessionKey: requesterContext.sessionKey,
-      task: params.task,
-      label: params.label,
-      spawnedAt: Date.now(),
-      cleanup: params.cleanup ?? "keep"
-    };
-    const childRoom = {
-      id: childRoomId,
-      name: params.label || `Subagent: ${params.task.slice(0, 50)}`,
-      type: ChannelType.SELF,
-      channelId: childSessionKey,
-      agentId: this.runtime.agentId,
-      worldId: this.runtime.agentId,
-      metadata: roomMetadata
-    };
-    await this.runtime.ensureRoomExists(childRoom);
-    const now2 = Date.now();
-    const archiveAfterMs = config.archiveAfterMinutes ? config.archiveAfterMinutes * 60000 : undefined;
-    const record = {
-      runId,
-      childSessionKey,
-      requesterSessionKey: requesterContext.sessionKey ?? "unknown",
-      requesterOrigin: normalizeDeliveryContext(requesterContext.origin),
-      requesterDisplayKey: requesterContext.sessionKey ?? "main",
-      task: params.task,
-      cleanup: params.cleanup ?? "keep",
-      label: params.label,
-      createdAt: now2,
-      startedAt: now2,
-      archiveAtMs: archiveAfterMs ? now2 + archiveAfterMs : undefined,
-      cleanupHandled: false,
-      roomId: childRoomId,
-      worldId: this.runtime.agentId
-    };
-    this.subagentRuns.set(runId, record);
-    this.emitSubagentEvent("SUBAGENT_SPAWN_REQUESTED", {
-      runId,
-      childSessionKey,
-      childRoomId,
-      requesterSessionKey: requesterContext.sessionKey,
-      requesterRoomId: requesterContext.roomId,
-      task: params.task,
-      label: params.label
-    });
-    const systemPrompt = this.buildSubagentSystemPrompt({
-      requesterSessionKey: requesterContext.sessionKey,
-      requesterOrigin: requesterContext.origin,
-      childSessionKey,
-      label: params.label,
-      task: params.task
-    });
-    const initialMessage = {
-      id: hashToUUID(`${runId}-initial`),
-      entityId: this.runtime.agentId,
-      agentId: this.runtime.agentId,
-      roomId: childRoomId,
-      content: {
-        text: params.task,
-        type: "text",
-        metadata: {
-          isSubagentTask: true,
-          runId,
-          systemPromptOverride: systemPrompt,
-          modelOverride: params.model || config.model,
-          thinkingOverride: params.thinking || config.thinking
-        }
-      }
-    };
-    this.executeSubagentRun(runId, initialMessage, params.runTimeoutSeconds).catch((error) => {
-      this.runtime.logger.error("Subagent execution error", { runId, error });
-      this.handleSubagentError(runId, error);
-    });
-    return {
-      status: "accepted",
-      childSessionKey,
-      childRoomId,
-      runId,
-      modelApplied: !!(params.model || config.model)
-    };
-  }
-  async executeSubagentRun(runId, initialMessage, timeoutSeconds) {
-    const config = this.getConfig();
-    const timeout = (timeoutSeconds ?? config.timeoutSeconds ?? 300) * 1000;
-    const controller = new AbortController;
-    this.activeRuns.set(runId, controller);
-    const timeoutId = timeout > 0 ? setTimeout(() => {
-      controller.abort();
-      this.handleSubagentTimeout(runId);
-    }, timeout) : null;
-    try {
-      await this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
-        runtime: this.runtime,
-        message: initialMessage,
-        source: "subagent"
-      });
-      await this.waitForCompletion(runId, timeout, controller.signal);
+        runtimeAgentId: this.runtime.agentId,
+        workingDirectory: task.metadata.workingDirectory,
+        appendOutput: async (line) => this.appendOutput(taskId, line),
+        updateProgress: async (p) => this.updateTaskProgress(taskId, p),
+        updateStep: async (stepId, status, output) => this.updateStep(taskId, stepId, status, output),
+        isCancelled: () => this.isTaskCancelled(taskId),
+        isPaused: () => this.isTaskPaused(taskId)
+      };
+      const execCtx = {
+        ...execCtxBase,
+        ...roomId ? { roomId } : {},
+        ...worldId ? { worldId } : {}
+      };
+      const result = await provider.executeTask(task, execCtx);
+      await this.setTaskResult(taskId, result);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      await this.setTaskError(taskId, msg);
     } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      this.activeRuns.delete(runId);
+      this.clearControl(taskId);
     }
   }
-  async waitForCompletion(runId, timeoutMs, signal) {
-    const startTime = Date.now();
-    const pollInterval = 500;
-    while (!signal.aborted) {
-      const record = this.subagentRuns.get(runId);
-      if (!record) {
-        return;
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  emit(type, taskId, data) {
+    const event = data ? { type, taskId, data } : { type, taskId };
+    this.emitter.emit(type, event);
+    this.emitter.emit("task", event);
+  }
+  async stop() {
+    this.emitter.removeAllListeners();
+    this.controlStates.clear();
+    this.executions.clear();
+  }
+  async getTaskContext() {
+    const current = await this.getCurrentTask();
+    const tasks = await this.getRecentTasks(10);
+    if (tasks.length === 0) {
+      return "No tasks have been created yet.";
+    }
+    const lines = [];
+    const active = current ?? tasks[0] ?? null;
+    if (active) {
+      const m = active.metadata;
+      lines.push(`## Current Task (selected): ${active.name}`);
+      lines.push(`- **Execution status**: ${m.status}`);
+      lines.push(`- **Progress**: ${m.progress}%`);
+      lines.push(`- **Provider**: ${m.providerLabel ?? m.providerId}`);
+      lines.push("");
+      if (active.description) {
+        lines.push("### Description");
+        lines.push(active.description);
+        lines.push("");
       }
-      if (record.endedAt) {
-        return;
+      if (m.steps.length > 0) {
+        lines.push("### Plan / Steps");
+        for (const s of m.steps) {
+          lines.push(`- [${s.status}] ${s.description}`);
+        }
+        lines.push("");
       }
-      if (Date.now() - startTime > timeoutMs + 5000) {
-        return;
+      if (m.output.length > 0) {
+        lines.push("### Task Output (history)");
+        lines.push("```");
+        lines.push(...m.output.slice(-200));
+        lines.push("```");
+        lines.push("");
       }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
     }
+    return lines.join(`
+`).trim();
   }
-  handleSubagentTimeout(runId) {
-    const record = this.subagentRuns.get(runId);
-    if (!record || record.endedAt) {
+}
+
+// src/services/messaging-service.ts
+import crypto2 from "node:crypto";
+import { EventEmitter as EventEmitter2 } from "node:events";
+import { EventType, Service as Service2 } from "@elizaos/core";
+class MessagingService extends Service2 {
+  static serviceType = "MESSAGING";
+  capabilityDescription = "Unified cross-platform messaging for sending messages to any supported channel";
+  emitter = new EventEmitter2;
+  adapters = new Map;
+  pendingDeliveries = new Map;
+  initialized = false;
+  static async start(runtime) {
+    const service = new MessagingService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    if (this.initialized) {
       return;
     }
-    record.endedAt = Date.now();
-    record.outcome = { status: "timeout" };
-    this.emitSubagentEvent("SUBAGENT_RUN_TIMEOUT", {
-      runId,
-      childSessionKey: record.childSessionKey,
-      childRoomId: record.roomId,
-      task: record.task,
-      status: "timeout"
+    this.initialized = true;
+    this.registerBuiltInAdapters();
+  }
+  registerBuiltInAdapters() {
+    this.registerAdapter({
+      channel: "discord",
+      isAvailable: () => {
+        const service = this.runtime.getService("DISCORD");
+        return !!service;
+      },
+      send: async (params) => this.sendViaDiscord(params)
     });
-    this.announceSubagentResult(runId).catch((err) => {
-      this.runtime.logger.error("Failed to announce timeout", { runId, error: err });
+    this.registerAdapter({
+      channel: "telegram",
+      isAvailable: () => {
+        const service = this.runtime.getService("TELEGRAM");
+        return !!service;
+      },
+      send: async (params) => this.sendViaTelegram(params)
     });
-  }
-  handleSubagentError(runId, error) {
-    const record = this.subagentRuns.get(runId);
-    if (!record) {
-      return;
-    }
-    record.endedAt = Date.now();
-    record.outcome = {
-      status: "error",
-      error: error instanceof Error ? error.message : String(error)
-    };
-    this.emitSubagentEvent("SUBAGENT_RUN_FAILED", {
-      runId,
-      childSessionKey: record.childSessionKey,
-      childRoomId: record.roomId,
-      task: record.task,
-      status: "error",
-      error: record.outcome.error
+    this.registerAdapter({
+      channel: "slack",
+      isAvailable: () => {
+        const service = this.runtime.getService("slack");
+        return !!service;
+      },
+      send: async (params) => this.sendViaSlack(params)
     });
-    this.announceSubagentResult(runId).catch((err) => {
-      this.runtime.logger.error("Failed to announce error", { runId, error: err });
+    this.registerAdapter({
+      channel: "whatsapp",
+      isAvailable: () => {
+        const service = this.runtime.getService("whatsapp");
+        return !!service;
+      },
+      send: async (params) => this.sendViaWhatsApp(params)
+    });
+    this.registerAdapter({
+      channel: "twitch",
+      isAvailable: () => {
+        const service = this.runtime.getService("twitch");
+        return !!service;
+      },
+      send: async (params) => this.sendViaTwitch(params)
+    });
+    this.registerAdapter({
+      channel: "internal",
+      isAvailable: () => true,
+      send: async (params) => this.sendViaInternal(params)
     });
   }
-  async handleRunEnded(payload) {
-    const p = payload;
-    if (!p.roomId) {
-      return;
-    }
-    for (const [runId, record] of this.subagentRuns.entries()) {
-      if (record.roomId === p.roomId && !record.endedAt) {
-        record.endedAt = Date.now();
-        record.outcome = { status: "ok" };
-        this.emitSubagentEvent("SUBAGENT_RUN_COMPLETED", {
-          runId,
-          childSessionKey: record.childSessionKey,
-          childRoomId: record.roomId,
-          task: record.task,
-          status: "completed",
-          startedAt: record.startedAt,
-          endedAt: record.endedAt,
-          durationMs: record.endedAt - (record.startedAt ?? record.createdAt)
-        });
-        await this.announceSubagentResult(runId);
-        break;
+  registerAdapter(adapter) {
+    this.adapters.set(adapter.channel, adapter);
+  }
+  getAdapter(channel) {
+    return this.adapters.get(channel);
+  }
+  getAvailableChannels() {
+    const channels = [];
+    for (const [channel, adapter] of this.adapters) {
+      if (adapter.isAvailable()) {
+        channels.push(channel);
       }
     }
+    return channels;
   }
-  async handleRunTimeout(payload) {
-    const p = payload;
-    if (!p.roomId) {
-      return;
+  async send(params) {
+    const idempotencyKey = params.idempotencyKey ?? crypto2.randomUUID();
+    const channel = params.target.channel;
+    const existing = this.pendingDeliveries.get(idempotencyKey);
+    if (existing) {
+      const result = {
+        success: existing.status.status === "sent" || existing.status.status === "delivered",
+        channel,
+        targetId: params.target.to
+      };
+      if (existing.status.messageId)
+        result.messageId = existing.status.messageId;
+      if (existing.status.error)
+        result.error = existing.status.error;
+      if (existing.status.status === "sent")
+        result.sentAt = existing.status.updatedAt;
+      return result;
+    }
+    const status = {
+      status: "pending",
+      updatedAt: Date.now()
+    };
+    this.pendingDeliveries.set(idempotencyKey, { params, status });
+    this.emitMessagingEvent("MESSAGING_SEND_REQUESTED", {
+      idempotencyKey,
+      channel,
+      targetId: params.target.to,
+      status: "pending"
+    });
+    const adapter = this.adapters.get(channel);
+    if (!adapter) {
+      const errorMsg = `No adapter registered for channel: ${channel}`;
+      const result = {
+        success: false,
+        channel,
+        targetId: params.target.to,
+        error: errorMsg
+      };
+      status.status = "failed";
+      status.error = errorMsg;
+      status.updatedAt = Date.now();
+      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
+        idempotencyKey,
+        channel,
+        targetId: params.target.to,
+        status: "failed",
+        error: errorMsg
+      });
+      return result;
+    }
+    if (!adapter.isAvailable()) {
+      const errorMsg = `${channel} service is not available`;
+      const result = {
+        success: false,
+        channel,
+        targetId: params.target.to,
+        error: errorMsg
+      };
+      status.status = "failed";
+      status.error = errorMsg;
+      status.updatedAt = Date.now();
+      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
+        idempotencyKey,
+        channel,
+        targetId: params.target.to,
+        status: "failed",
+        error: errorMsg
+      });
+      return result;
     }
-    for (const [runId, record] of this.subagentRuns.entries()) {
-      if (record.roomId === p.roomId && !record.endedAt) {
-        this.handleSubagentTimeout(runId);
-        break;
+    try {
+      const result = await adapter.send({ ...params, idempotencyKey });
+      status.status = result.success ? "sent" : "failed";
+      if (result.messageId)
+        status.messageId = result.messageId;
+      if (result.error)
+        status.error = result.error;
+      status.updatedAt = Date.now();
+      if (result.success) {
+        const sentPayload = {
+          idempotencyKey,
+          channel,
+          targetId: params.target.to,
+          status: "sent"
+        };
+        if (result.messageId)
+          sentPayload.messageId = result.messageId;
+        if (result.sentAt)
+          sentPayload.sentAt = result.sentAt;
+        this.emitMessagingEvent("MESSAGING_SENT", sentPayload);
+      } else {
+        const failedPayload = {
+          idempotencyKey,
+          channel,
+          targetId: params.target.to,
+          status: "failed"
+        };
+        if (result.error)
+          failedPayload.error = result.error;
+        this.emitMessagingEvent("MESSAGING_SEND_FAILED", failedPayload);
       }
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      status.status = "failed";
+      status.error = errorMessage;
+      status.updatedAt = Date.now();
+      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
+        idempotencyKey,
+        channel,
+        targetId: params.target.to,
+        status: "failed",
+        error: errorMessage
+      });
+      return {
+        success: false,
+        channel,
+        targetId: params.target.to,
+        error: errorMessage
+      };
     }
   }
-  async announceSubagentResult(runId) {
-    const record = this.subagentRuns.get(runId);
-    if (!record) {
-      return false;
-    }
-    if (record.cleanupCompletedAt || record.cleanupHandled) {
-      return false;
+  async sendToDeliveryContext(deliveryContext, content, options) {
+    const channel = this.normalizeChannel(deliveryContext.channel);
+    const to = deliveryContext.to ?? deliveryContext.accountId ?? "";
+    if (!to) {
+      return {
+        success: false,
+        channel,
+        targetId: "",
+        error: "No recipient specified in delivery context"
+      };
     }
-    record.cleanupHandled = true;
-    let reply;
-    if (record.roomId) {
-      const memories = await this.runtime.getMemories({
-        roomId: record.roomId,
-        count: 10
-      });
-      const lastAssistant = memories.filter((m) => m.entityId === this.runtime.agentId).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0];
-      reply = lastAssistant?.content?.text;
+    return this.send({
+      target: {
+        channel,
+        to,
+        ...deliveryContext.accountId ? { accountId: deliveryContext.accountId } : {},
+        ...deliveryContext.threadId !== undefined ? { threadId: deliveryContext.threadId } : {}
+      },
+      content,
+      ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+      ...options?.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  async sendToRoom(roomId, content, options) {
+    const room = await this.runtime.getRoom(roomId);
+    if (!room) {
+      return {
+        success: false,
+        channel: "unknown",
+        targetId: roomId,
+        error: `Room not found: ${roomId}`
+      };
     }
-    const durationMs = record.endedAt ? record.endedAt - (record.startedAt ?? record.createdAt) : undefined;
-    const statsLine = `Runtime: ${formatDurationShort(durationMs) ?? "n/a"} • Session: ${record.childSessionKey}`;
-    const outcome = record.outcome ?? { status: "unknown" };
-    const statusLabel = outcome.status === "ok" ? "completed successfully" : outcome.status === "timeout" ? "timed out" : outcome.status === "error" ? `failed: ${outcome.error || "unknown error"}` : "finished with unknown status";
-    const taskLabel = record.label || record.task || "background task";
-    const triggerMessage = [
-      `A background task "${taskLabel}" just ${statusLabel}.`,
-      "",
-      "Findings:",
-      reply || "(no output)",
-      "",
-      statsLine,
-      "",
-      "Summarize this naturally for the user. Keep it brief (1-2 sentences).",
-      "Do not mention technical details like tokens, stats, or that this was a background task.",
-      "You can respond with NO_REPLY if no announcement is needed."
-    ].join(`
-`);
-    if (record.requesterSessionKey && record.requesterSessionKey !== "unknown") {
-      const requesterRoomId = sessionKeyToRoomId(record.requesterSessionKey, extractAgentIdFromSessionKey(record.requesterSessionKey));
-      const announceMessage = {
-        id: hashToUUID(`${runId}-announce`),
-        entityId: this.runtime.agentId,
-        agentId: this.runtime.agentId,
-        roomId: requesterRoomId,
-        content: {
-          text: triggerMessage,
-          type: "text",
-          metadata: {
-            isSubagentAnnouncement: true,
-            subagentRunId: runId,
-            deliveryContext: record.requesterOrigin
-          }
-        }
+    const metadata = room.metadata;
+    const channel = this.normalizeChannel(metadata?.messagingChannel);
+    const to = metadata?.messagingTo ?? room.channelId ?? "";
+    if (!to) {
+      return {
+        success: false,
+        channel,
+        targetId: roomId,
+        error: "Room has no messaging target configured"
       };
-      await this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
-        runtime: this.runtime,
-        message: announceMessage,
-        source: "subagent_announce"
-      });
     }
-    this.emitSubagentEvent("SUBAGENT_ANNOUNCE_SENT", {
-      runId,
-      childSessionKey: record.childSessionKey,
-      requesterSessionKey: record.requesterSessionKey,
-      task: record.task,
-      outcome
+    return this.send({
+      target: {
+        channel,
+        to,
+        ...metadata?.messagingAccountId ? { accountId: metadata.messagingAccountId } : {},
+        ...metadata?.messagingThreadId !== undefined ? { threadId: metadata.messagingThreadId } : {}
+      },
+      content,
+      ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+      ...options?.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}
     });
-    record.cleanupCompletedAt = Date.now();
-    if (record.cleanup === "delete") {
-      this.subagentRuns.delete(runId);
-    }
-    return true;
   }
-  buildSubagentSystemPrompt(params) {
-    const taskText = typeof params.task === "string" && params.task.trim() ? params.task.replace(/\s+/g, " ").trim() : "{{TASK_DESCRIPTION}}";
-    const lines = [
-      "# Subagent Context",
-      "",
-      "You are a **subagent** spawned by the main agent for a specific task.",
-      "",
-      "## Your Role",
-      `- You were created to handle: ${taskText}`,
-      "- Complete this task. That's your entire purpose.",
-      "- You are NOT the main agent. Don't try to be.",
-      "",
-      "## Rules",
-      "1. **Stay focused** - Do your assigned task, nothing else",
-      "2. **Complete the task** - Your final message will be automatically reported to the main agent",
-      "3. **Don't initiate** - No heartbeats, no proactive actions, no side quests",
-      "4. **Be ephemeral** - You may be terminated after task completion. That's fine.",
-      "",
-      "## Output Format",
-      "When complete, your final response should include:",
-      "- What you accomplished or found",
-      "- Any relevant details the main agent should know",
-      "- Keep it concise but informative",
-      "",
-      "## What You DON'T Do",
-      "- NO user conversations (that's main agent's job)",
-      "- NO external messages unless explicitly tasked with a specific recipient",
-      "- NO cron jobs or persistent state",
-      "- NO pretending to be the main agent",
-      "",
-      "## Session Context",
-      params.label ? `- Label: ${params.label}` : undefined,
-      params.requesterSessionKey ? `- Requester session: ${params.requesterSessionKey}` : undefined,
-      params.requesterOrigin?.channel ? `- Requester channel: ${params.requesterOrigin.channel}` : undefined,
-      `- Your session: ${params.childSessionKey}`,
-      ""
-    ].filter((line) => line !== undefined);
-    return lines.join(`
-`);
+  async sendToSession(sessionKey, content, options) {
+    const agentId = extractAgentIdFromSessionKey(sessionKey);
+    const roomId = sessionKeyToRoomId(sessionKey, agentId);
+    return this.sendToRoom(roomId, content, options);
   }
-  async sendToAgent(params, requesterContext) {
-    const runId = crypto2.randomUUID();
-    const policy = this.getAgentToAgentPolicy();
-    let targetSessionKey = params.sessionKey;
-    if (!targetSessionKey && params.label) {
-      const matchingRun = this.findSubagentRunByLabel(params.label, params.agentId);
-      if (matchingRun) {
-        targetSessionKey = matchingRun.childSessionKey;
-      } else {
+  async sendViaDiscord(params) {
+    const discordService = this.runtime.getService("DISCORD");
+    if (!discordService?.client) {
+      return {
+        success: false,
+        channel: "discord",
+        targetId: params.target.to,
+        error: "Discord service not available"
+      };
+    }
+    try {
+      const channel = await discordService.client.channels.fetch(params.target.to);
+      if (!channel?.send) {
         return {
-          status: "error",
-          runId,
-          error: `No subagent found with label "${params.label}"`
+          success: false,
+          channel: "discord",
+          targetId: params.target.to,
+          error: "Channel not found or not a text channel"
         };
       }
+      const message = await channel.send({
+        content: params.content.text,
+        ...params.target.replyToMessageId ? { reply: { messageReference: params.target.replyToMessageId } } : {}
+      });
+      return {
+        success: true,
+        messageId: message.id,
+        channel: "discord",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "discord",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    if (!targetSessionKey) {
+  }
+  async sendViaTelegram(params) {
+    const telegramService = this.runtime.getService("TELEGRAM");
+    if (!telegramService?.bot?.telegram) {
+      return {
+        success: false,
+        channel: "telegram",
+        targetId: params.target.to,
+        error: "Telegram service not available"
+      };
+    }
+    try {
+      const chatId = Number.isNaN(Number(params.target.to)) ? params.target.to : Number(params.target.to);
+      const result = await telegramService.bot.telegram.sendMessage(chatId, params.content.text, {
+        reply_to_message_id: params.target.replyToMessageId ? Number(params.target.replyToMessageId) : undefined,
+        disable_web_page_preview: params.content.disableLinkPreview,
+        disable_notification: params.content.silent
+      });
+      return {
+        success: true,
+        messageId: String(result.message_id),
+        channel: "telegram",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
       return {
-        status: "error",
-        runId,
-        error: "Either sessionKey or label is required"
+        success: false,
+        channel: "telegram",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
       };
     }
-    const requesterAgentId = requesterContext.sessionKey ? extractAgentIdFromSessionKey(requesterContext.sessionKey) : this.runtime.character?.name ?? "unknown";
-    const targetAgentId = extractAgentIdFromSessionKey(targetSessionKey);
-    if (requesterAgentId !== targetAgentId) {
-      if (!policy.enabled) {
-        return {
-          status: "forbidden",
-          runId,
-          error: "Agent-to-agent messaging is disabled. Set settings.agentToAgent.enabled=true to allow cross-agent sends."
-        };
-      }
-      if (!policy.isAllowed(requesterAgentId, targetAgentId)) {
-        return {
-          status: "forbidden",
-          runId,
-          error: "Agent-to-agent messaging denied by policy."
-        };
-      }
+  }
+  async sendViaSlack(params) {
+    const slackService = this.runtime.getService("slack");
+    if (!slackService?.sendMessage) {
+      return {
+        success: false,
+        channel: "slack",
+        targetId: params.target.to,
+        error: "Slack service not available or sendMessage method not found"
+      };
     }
-    const targetRoomId = sessionKeyToRoomId(targetSessionKey, targetAgentId);
-    const contextMessage = this.buildAgentToAgentContext({
-      requesterSessionKey: requesterContext.sessionKey,
-      targetSessionKey
-    });
-    const message = {
-      id: hashToUUID(`${runId}-a2a`),
-      entityId: this.runtime.agentId,
-      agentId: this.runtime.agentId,
-      roomId: targetRoomId,
-      content: {
-        text: params.message,
-        type: "text",
-        metadata: {
-          isAgentToAgent: true,
-          runId,
-          senderSessionKey: requesterContext.sessionKey,
-          senderRoomId: requesterContext.roomId,
-          systemPromptOverride: contextMessage
-        }
-      }
-    };
-    const timeoutMs = (params.timeoutSeconds ?? 30) * 1000;
-    if (params.timeoutSeconds === 0) {
-      this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
-        runtime: this.runtime,
-        message,
-        source: "a2a"
-      }).catch((err) => {
-        this.runtime.logger.error("A2A send error", { runId, error: err });
-      });
-      this.emitSubagentEvent("A2A_MESSAGE_SENT", {
-        runId,
-        childSessionKey: targetSessionKey,
-        requesterSessionKey: requesterContext.sessionKey,
-        task: params.message
+    try {
+      const result = await slackService.sendMessage(params.target.to, params.content.text, {
+        ...params.target.threadId ? { threadTs: String(params.target.threadId) } : {},
+        replyBroadcast: false
       });
       return {
-        status: "accepted",
-        runId,
-        sessionKey: targetSessionKey,
-        delivery: { status: "pending", mode: "async" }
+        success: true,
+        messageId: result.ts,
+        channel: "slack",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "slack",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
       };
     }
-    const sentAt = Date.now();
-    await this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
-      runtime: this.runtime,
-      message,
-      source: "a2a"
-    });
-    const pollIntervalMs = 500;
-    const maxPolls = Math.ceil(timeoutMs / pollIntervalMs);
-    let lastReply;
-    for (let poll = 0;poll < maxPolls; poll++) {
-      await new Promise((r) => setTimeout(r, pollIntervalMs));
-      const memories = await this.runtime.getMemories({
-        roomId: targetRoomId,
-        count: 10
-      });
-      const newReplies = memories.filter((m) => m.entityId === this.runtime.agentId && m.id !== message.id && m.createdAt && m.createdAt > sentAt);
-      if (newReplies.length > 0) {
-        lastReply = newReplies.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0];
-        break;
-      }
+  }
+  async sendViaWhatsApp(params) {
+    const whatsappService = this.runtime.getService("whatsapp");
+    if (!whatsappService?.sendText) {
+      return {
+        success: false,
+        channel: "whatsapp",
+        targetId: params.target.to,
+        error: "WhatsApp service not available or sendText method not found"
+      };
     }
-    this.emitSubagentEvent("A2A_MESSAGE_SENT", {
-      runId,
-      childSessionKey: targetSessionKey,
-      requesterSessionKey: requesterContext.sessionKey,
-      task: params.message
-    });
-    if (!lastReply) {
+    try {
+      const result = await whatsappService.sendText(params.target.to, params.content.text);
+      const messageId = result.messages?.[0]?.id;
       return {
-        status: "timeout",
-        runId,
-        sessionKey: targetSessionKey,
-        error: `No response received within ${params.timeoutSeconds ?? 30} seconds`,
-        delivery: { status: "timeout", mode: "sync" }
+        success: true,
+        ...messageId ? { messageId } : {},
+        channel: "whatsapp",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "whatsapp",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
       };
     }
-    return {
-      status: "ok",
-      runId,
-      sessionKey: targetSessionKey,
-      reply: lastReply.content?.text,
-      delivery: { status: "delivered", mode: "sync" }
-    };
-  }
-  buildAgentToAgentContext(params) {
-    return [
-      "# Agent-to-Agent Message Context",
-      "",
-      "This message was sent by another agent session.",
-      params.requesterSessionKey ? `- Sender: ${params.requesterSessionKey}` : undefined,
-      `- Target: ${params.targetSessionKey}`,
-      "",
-      "Process this message and respond appropriately."
-    ].filter((l) => l !== undefined).join(`
-`);
-  }
-  getSubagentRun(runId) {
-    return this.subagentRuns.get(runId);
   }
-  findSubagentRunByLabel(label, agentId) {
-    const normalizedLabel = label.toLowerCase().trim();
-    const normalizedAgentId = agentId ? normalizeAgentId2(agentId) : undefined;
-    for (const run of this.subagentRuns.values()) {
-      const runLabel = run.label?.toLowerCase().trim();
-      if (runLabel !== normalizedLabel) {
-        continue;
-      }
-      if (normalizedAgentId) {
-        const runAgentId = extractAgentIdFromSessionKey(run.childSessionKey);
-        if (normalizeAgentId2(runAgentId) !== normalizedAgentId) {
-          continue;
-        }
-      }
-      if (!run.endedAt) {
-        return run;
-      }
+  async sendViaTwitch(params) {
+    const twitchService = this.runtime.getService("twitch");
+    if (!twitchService?.sendMessage) {
+      return {
+        success: false,
+        channel: "twitch",
+        targetId: params.target.to,
+        error: "Twitch service not available or sendMessage method not found"
+      };
+    }
+    try {
+      const result = await twitchService.sendMessage(params.content.text, {
+        channel: params.target.to,
+        ...params.target.replyToMessageId ? { replyTo: params.target.replyToMessageId } : {}
+      });
+      return {
+        success: result.success,
+        ...result.messageId !== undefined ? { messageId: result.messageId } : {},
+        channel: "twitch",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "twitch",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    const completedRuns = [...this.subagentRuns.values()].filter((run) => {
-      const runLabel = run.label?.toLowerCase().trim();
-      if (runLabel !== normalizedLabel) {
-        return false;
-      }
-      if (normalizedAgentId) {
-        const runAgentId = extractAgentIdFromSessionKey(run.childSessionKey);
-        if (normalizeAgentId2(runAgentId) !== normalizedAgentId) {
-          return false;
-        }
-      }
-      return true;
-    }).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
-    return completedRuns[0];
   }
-  listSubagentRuns(requesterSessionKey) {
-    const runs = [...this.subagentRuns.values()];
-    if (!requesterSessionKey) {
-      return runs;
+  async sendViaInternal(params) {
+    const roomId = params.target.to;
+    const messageId = crypto2.randomUUID();
+    try {
+      const memory = {
+        id: messageId,
+        entityId: this.runtime.agentId,
+        agentId: this.runtime.agentId,
+        roomId,
+        content: {
+          text: params.content.text,
+          type: "text",
+          source: "internal",
+          metadata: {
+            isInternalMessage: true,
+            idempotencyKey: params.idempotencyKey
+          }
+        },
+        createdAt: Date.now()
+      };
+      await this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
+        runtime: this.runtime,
+        message: memory,
+        source: "internal_messaging"
+      });
+      return {
+        success: true,
+        messageId,
+        channel: "internal",
+        targetId: params.target.to,
+        sentAt: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        channel: "internal",
+        targetId: params.target.to,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    return runs.filter((r) => r.requesterSessionKey === requesterSessionKey);
   }
-  cancelSubagentRun(runId) {
-    const controller = this.activeRuns.get(runId);
-    if (controller) {
-      controller.abort();
-      return true;
+  normalizeChannel(channel) {
+    if (!channel) {
+      return "unknown";
     }
-    return false;
+    const lower = channel.toLowerCase();
+    if (lower === "discord" || lower.includes("discord")) {
+      return "discord";
+    }
+    if (lower === "telegram" || lower.includes("telegram")) {
+      return "telegram";
+    }
+    if (lower === "slack" || lower.includes("slack")) {
+      return "slack";
+    }
+    if (lower === "whatsapp" || lower.includes("whatsapp")) {
+      return "whatsapp";
+    }
+    if (lower === "twitch" || lower.includes("twitch")) {
+      return "twitch";
+    }
+    if (lower === "google_chat" || lower.includes("google") || lower.includes("gchat")) {
+      return "google_chat";
+    }
+    if (lower === "internal" || lower === "a2a") {
+      return "internal";
+    }
+    return "unknown";
   }
   on(event, handler) {
     this.emitter.on(event, handler);
@@ -2504,46 +2444,22 @@ class SubagentService extends Service2 {
   off(event, handler) {
     this.emitter.off(event, handler);
   }
-  emitSubagentEvent(type, payload) {
+  emitMessagingEvent(type, payload) {
     this.emitter.emit(type, payload);
-    this.emitter.emit("task", { type, ...payload });
-  }
-  startSweeper() {
-    if (this.sweeper) {
-      return;
-    }
-    this.sweeper = setInterval(() => {
-      this.sweepOldRuns();
-    }, 60000);
-    this.sweeper.unref?.();
-  }
-  sweepOldRuns() {
-    const now2 = Date.now();
-    for (const [runId, record] of this.subagentRuns.entries()) {
-      if (record.archiveAtMs && record.archiveAtMs <= now2) {
-        this.subagentRuns.delete(runId);
-      }
-    }
+    this.emitter.emit("messaging", { type, ...payload });
   }
   async stop() {
-    if (this.sweeper) {
-      clearInterval(this.sweeper);
-      this.sweeper = null;
-    }
-    for (const controller of this.activeRuns.values()) {
-      controller.abort();
-    }
-    this.activeRuns.clear();
+    this.pendingDeliveries.clear();
     this.emitter.removeAllListeners();
   }
 }
 
 // src/services/sandbox-service.ts
-import { EventEmitter as EventEmitter3 } from "node:events";
 import { spawn } from "node:child_process";
+import { EventEmitter as EventEmitter3 } from "node:events";
 import fs from "node:fs/promises";
-import path from "node:path";
 import os from "node:os";
+import path from "node:path";
 import { Service as Service3 } from "@elizaos/core";
 var DEFAULT_DOCKER_CONFIG = {
   image: "ubuntu:22.04",
@@ -2684,7 +2600,7 @@ class SandboxService extends Service3 {
     this.contexts.set(trimmedKey, context);
     this.emitSandboxEvent("SANDBOX_CREATED", {
       sessionKey: trimmedKey,
-      roomId: context.roomId,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
       containerName
     });
     return context;
@@ -2716,7 +2632,7 @@ class SandboxService extends Service3 {
     this.contexts.delete(sessionKey);
     this.emitSandboxEvent("SANDBOX_DESTROYED", {
       sessionKey,
-      roomId: context.roomId,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
       containerName: context.containerName
     });
   }
@@ -2728,7 +2644,7 @@ class SandboxService extends Service3 {
     const startTime = Date.now();
     this.emitSandboxEvent("SANDBOX_COMMAND_STARTED", {
       sessionKey,
-      roomId: context.roomId,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
       containerName: context.containerName,
       command: params.command
     });
@@ -2736,7 +2652,7 @@ class SandboxService extends Service3 {
       const result = await this.executeInContainer(context, params);
       this.emitSandboxEvent("SANDBOX_COMMAND_COMPLETED", {
         sessionKey,
-        roomId: context.roomId,
+        ...context.roomId !== undefined ? { roomId: context.roomId } : {},
         containerName: context.containerName,
         command: params.command,
         result
@@ -2755,7 +2671,7 @@ class SandboxService extends Service3 {
       };
       this.emitSandboxEvent("SANDBOX_COMMAND_FAILED", {
         sessionKey,
-        roomId: context.roomId,
+        ...context.roomId !== undefined ? { roomId: context.roomId } : {},
         containerName: context.containerName,
         command: params.command,
         result,
@@ -2792,15 +2708,17 @@ class SandboxService extends Service3 {
       }
       child.on("close", (code) => {
         clearTimeout(timeoutId);
-        resolve({
+        const result = {
           success: code === 0 && !timedOut,
           exitCode: code ?? 1,
           stdout: stdout.slice(0, 1e5),
           stderr: stderr.slice(0, 1e5),
           durationMs: Date.now() - startTime,
-          timedOut,
-          error: timedOut ? "Command timed out" : undefined
-        });
+          timedOut
+        };
+        if (timedOut)
+          result.error = "Command timed out";
+        resolve(result);
       });
       child.on("error", (error) => {
         clearTimeout(timeoutId);
@@ -2838,15 +2756,17 @@ class SandboxService extends Service3 {
       });
       child.on("close", (code) => {
         clearTimeout(timeoutId);
-        resolve({
+        const result = {
           success: code === 0 && !timedOut,
           exitCode: code ?? 1,
           stdout: stdout.slice(0, 1e5),
           stderr: stderr.slice(0, 1e5),
           durationMs: Date.now() - startTime,
-          timedOut,
-          error: timedOut ? "Command timed out" : undefined
-        });
+          timedOut
+        };
+        if (timedOut)
+          result.error = "Command timed out";
+        resolve(result);
       });
       child.on("error", (error) => {
         clearTimeout(timeoutId);
@@ -2897,15 +2817,17 @@ class SandboxService extends Service3 {
       }
       child.on("close", (code) => {
         clearTimeout(timeoutId);
-        resolve({
+        const result = {
           success: code === 0 && !timedOut,
           exitCode: code ?? 1,
           stdout: stdout.slice(0, 1e5),
           stderr: stderr.slice(0, 1e5),
           durationMs: Date.now() - startTime,
-          timedOut,
-          error: timedOut ? "Command timed out" : undefined
-        });
+          timedOut
+        };
+        if (timedOut)
+          result.error = "Command timed out";
+        resolve(result);
       });
       child.on("error", (error) => {
         clearTimeout(timeoutId);
@@ -2950,10 +2872,7 @@ class SandboxService extends Service3 {
       `name=^${context.containerName}$`
     ]);
     if (checkResult.stdout.trim()) {
-      const startResult = await this.executeDockerCommand([
-        "start",
-        context.containerName
-      ]);
+      const startResult = await this.executeDockerCommand(["start", context.containerName]);
       if (startResult.success) {
         this.activeContainers.add(context.containerName);
         return;
@@ -3020,21 +2939,21 @@ class SandboxService extends Service3 {
     browserArgs.push(config.browser.image);
     const result = await this.executeDockerCommand(browserArgs);
     if (!result.success) {
-      this.runtime.logger.error("Failed to start browser container", {
+      this.runtime.logger.error({
         sessionKey,
         error: result.stderr
-      });
+      }, "Failed to start browser container");
       return null;
     }
     const browserContext = {
       bridgeUrl: `http://localhost:${config.browser.cdpPort}`,
-      noVncUrl: config.browser.enableNoVnc ? `http://localhost:${config.browser.noVncPort}` : undefined,
+      ...config.browser.enableNoVnc ? { noVncUrl: `http://localhost:${config.browser.noVncPort}` } : {},
       containerName: browserContainerName
     };
     context.browser = browserContext;
     this.emitSandboxEvent("SANDBOX_BROWSER_STARTED", {
       sessionKey,
-      roomId: context.roomId,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
       containerName: browserContainerName
     });
     return browserContext;
@@ -3047,10 +2966,10 @@ class SandboxService extends Service3 {
     await this.stopContainer(context.browser.containerName);
     this.emitSandboxEvent("SANDBOX_BROWSER_STOPPED", {
       sessionKey,
-      roomId: context.roomId,
+      ...context.roomId !== undefined ? { roomId: context.roomId } : {},
       containerName: context.browser.containerName
     });
-    context.browser = undefined;
+    delete context.browser;
   }
   startSweeper() {
     if (this.sweeper) {
@@ -3073,10 +2992,10 @@ class SandboxService extends Service3 {
       const tooOld = now2 - context.createdAt > maxAgeMs;
       if (idle || tooOld) {
         this.destroySandbox(sessionKey).catch((err) => {
-          this.runtime.logger.error("Failed to destroy idle sandbox", {
+          this.runtime.logger.error({
             sessionKey,
-            error: err
-          });
+            error: err instanceof Error ? err.message : String(err)
+          }, "Failed to destroy idle sandbox");
         });
       }
     }
@@ -3103,19 +3022,24 @@ class SandboxService extends Service3 {
   }
 }
 
-// src/services/messaging-service.ts
-import { EventEmitter as EventEmitter4 } from "node:events";
+// src/services/subagent-service.ts
 import crypto3 from "node:crypto";
-import { Service as Service4, EventType as EventType2 } from "@elizaos/core";
-class MessagingService extends Service4 {
-  static serviceType = "MESSAGING";
-  capabilityDescription = "Unified cross-platform messaging for sending messages to any supported channel";
+import { EventEmitter as EventEmitter4 } from "node:events";
+import {
+  ChannelType,
+  EventType as EventType2,
+  Service as Service4
+} from "@elizaos/core";
+class SubagentService extends Service4 {
+  static serviceType = "SUBAGENT";
+  capabilityDescription = "Manages subagent spawning, lifecycle, and communication";
   emitter = new EventEmitter4;
-  adapters = new Map;
-  pendingDeliveries = new Map;
+  subagentRuns = new Map;
+  activeRuns = new Map;
+  sweeper = null;
   initialized = false;
   static async start(runtime) {
-    const service = new MessagingService(runtime);
+    const service = new SubagentService(runtime);
     await service.initialize();
     return service;
   }
@@ -3124,472 +3048,636 @@ class MessagingService extends Service4 {
       return;
     }
     this.initialized = true;
-    this.registerBuiltInAdapters();
-  }
-  registerBuiltInAdapters() {
-    this.registerAdapter({
-      channel: "discord",
-      isAvailable: () => {
-        const service = this.runtime.getService("DISCORD");
-        return !!service;
-      },
-      send: async (params) => this.sendViaDiscord(params)
-    });
-    this.registerAdapter({
-      channel: "telegram",
-      isAvailable: () => {
-        const service = this.runtime.getService("TELEGRAM");
-        return !!service;
-      },
-      send: async (params) => this.sendViaTelegram(params)
-    });
-    this.registerAdapter({
-      channel: "slack",
-      isAvailable: () => {
-        const service = this.runtime.getService("slack");
-        return !!service;
-      },
-      send: async (params) => this.sendViaSlack(params)
-    });
-    this.registerAdapter({
-      channel: "whatsapp",
-      isAvailable: () => {
-        const service = this.runtime.getService("whatsapp");
-        return !!service;
-      },
-      send: async (params) => this.sendViaWhatsApp(params)
-    });
-    this.registerAdapter({
-      channel: "twitch",
-      isAvailable: () => {
-        const service = this.runtime.getService("twitch");
-        return !!service;
-      },
-      send: async (params) => this.sendViaTwitch(params)
+    this.runtime.registerEvent(EventType2.RUN_ENDED, async (payload) => {
+      await this.handleRunEnded(payload);
     });
-    this.registerAdapter({
-      channel: "internal",
-      isAvailable: () => true,
-      send: async (params) => this.sendViaInternal(params)
+    this.runtime.registerEvent(EventType2.RUN_TIMEOUT, async (payload) => {
+      await this.handleRunTimeout(payload);
     });
+    this.startSweeper();
   }
-  registerAdapter(adapter) {
-    this.adapters.set(adapter.channel, adapter);
-  }
-  getAdapter(channel) {
-    return this.adapters.get(channel);
-  }
-  getAvailableChannels() {
-    const channels = [];
-    for (const [channel, adapter] of this.adapters) {
-      if (adapter.isAvailable()) {
-        channels.push(channel);
-      }
-    }
-    return channels;
-  }
-  async send(params) {
-    const idempotencyKey = params.idempotencyKey ?? crypto3.randomUUID();
-    const channel = params.target.channel;
-    const existing = this.pendingDeliveries.get(idempotencyKey);
-    if (existing) {
-      return {
-        success: existing.status.status === "sent" || existing.status.status === "delivered",
-        messageId: existing.status.messageId,
-        channel,
-        targetId: params.target.to,
-        error: existing.status.error,
-        sentAt: existing.status.status === "sent" ? existing.status.updatedAt : undefined
-      };
-    }
-    const status = {
-      status: "pending",
-      updatedAt: Date.now()
+  getConfig() {
+    const settings = this.runtime.character?.settings;
+    const subagents = settings?.subagents ?? {};
+    return {
+      enabled: subagents.enabled !== false,
+      ...subagents.model !== undefined ? { model: subagents.model } : {},
+      ...subagents.thinking !== undefined ? { thinking: subagents.thinking } : {},
+      timeoutSeconds: subagents.timeoutSeconds ?? 300,
+      allowAgents: subagents.allowAgents ?? [],
+      archiveAfterMinutes: subagents.archiveAfterMinutes ?? 60
     };
-    this.pendingDeliveries.set(idempotencyKey, { params, status });
-    this.emitMessagingEvent("MESSAGING_SEND_REQUESTED", {
-      idempotencyKey,
-      channel,
-      targetId: params.target.to,
-      status: "pending"
-    });
-    const adapter = this.adapters.get(channel);
-    if (!adapter) {
-      const result = {
-        success: false,
-        channel,
-        targetId: params.target.to,
-        error: `No adapter registered for channel: ${channel}`
-      };
-      status.status = "failed";
-      status.error = result.error;
-      status.updatedAt = Date.now();
-      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
-        idempotencyKey,
-        channel,
-        targetId: params.target.to,
-        status: "failed",
-        error: result.error
-      });
-      return result;
-    }
-    if (!adapter.isAvailable()) {
-      const result = {
-        success: false,
-        channel,
-        targetId: params.target.to,
-        error: `${channel} service is not available`
-      };
-      status.status = "failed";
-      status.error = result.error;
-      status.updatedAt = Date.now();
-      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
-        idempotencyKey,
-        channel,
-        targetId: params.target.to,
-        status: "failed",
-        error: result.error
-      });
-      return result;
-    }
-    try {
-      const result = await adapter.send({ ...params, idempotencyKey });
-      status.status = result.success ? "sent" : "failed";
-      status.messageId = result.messageId;
-      status.error = result.error;
-      status.updatedAt = Date.now();
-      if (result.success) {
-        this.emitMessagingEvent("MESSAGING_SENT", {
-          idempotencyKey,
-          messageId: result.messageId,
-          channel,
-          targetId: params.target.to,
-          status: "sent",
-          sentAt: result.sentAt
-        });
-      } else {
-        this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
-          idempotencyKey,
-          channel,
-          targetId: params.target.to,
-          status: "failed",
-          error: result.error
-        });
+  }
+  getAgentToAgentPolicy() {
+    const settings = this.runtime.character?.settings;
+    const a2aConfig = settings?.agentToAgent ?? {};
+    const enabled = a2aConfig.enabled === true;
+    const allowRules = (a2aConfig.allow ?? []).map((rule) => ({
+      source: rule.source ?? "*",
+      target: rule.target ?? "*"
+    }));
+    return {
+      enabled,
+      allowRules,
+      isAllowed: (sourceAgentId, targetAgentId) => {
+        if (!enabled) {
+          return false;
+        }
+        if (sourceAgentId === targetAgentId) {
+          return true;
+        }
+        const sourceNorm = normalizeAgentId2(sourceAgentId);
+        const targetNorm = normalizeAgentId2(targetAgentId);
+        for (const rule of allowRules) {
+          const sourceMatch = rule.source === "*" || normalizeAgentId2(rule.source) === sourceNorm;
+          const targetMatch = rule.target === "*" || normalizeAgentId2(rule.target) === targetNorm;
+          if (sourceMatch && targetMatch) {
+            return true;
+          }
+        }
+        return false;
       }
-      return result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      status.status = "failed";
-      status.error = errorMessage;
-      status.updatedAt = Date.now();
-      this.emitMessagingEvent("MESSAGING_SEND_FAILED", {
-        idempotencyKey,
-        channel,
-        targetId: params.target.to,
-        status: "failed",
-        error: errorMessage
-      });
+    };
+  }
+  async spawnSubagent(params, requesterContext) {
+    const config = this.getConfig();
+    if (!config.enabled) {
       return {
-        success: false,
-        channel,
-        targetId: params.target.to,
-        error: errorMessage
+        status: "forbidden",
+        error: "Subagent spawning is disabled"
       };
     }
-  }
-  async sendToDeliveryContext(deliveryContext, content, options) {
-    const channel = this.normalizeChannel(deliveryContext.channel);
-    const to = deliveryContext.to ?? deliveryContext.accountId ?? "";
-    if (!to) {
+    if (requesterContext.sessionKey && isSubagentSessionKey2(requesterContext.sessionKey)) {
       return {
-        success: false,
-        channel,
-        targetId: "",
-        error: "No recipient specified in delivery context"
+        status: "forbidden",
+        error: "sessions_spawn is not allowed from sub-agent sessions"
       };
     }
-    return this.send({
-      target: {
-        channel,
-        to,
-        accountId: deliveryContext.accountId,
-        threadId: deliveryContext.threadId
-      },
-      content,
-      idempotencyKey: options?.idempotencyKey,
-      timeoutMs: options?.timeoutMs
+    const requesterAgentId = requesterContext.sessionKey ? extractAgentIdFromSessionKey(requesterContext.sessionKey) : this.runtime.character?.name ?? "unknown";
+    const targetAgentId = params.agentId ? normalizeAgentId2(params.agentId) : requesterAgentId;
+    if (targetAgentId !== requesterAgentId) {
+      const allowAgents = config.allowAgents ?? [];
+      const allowAny = allowAgents.some((v) => v.trim() === "*");
+      const allowSet = new Set(allowAgents.filter((v) => v.trim() && v.trim() !== "*").map((v) => normalizeAgentId2(v)));
+      if (!allowAny && !allowSet.has(targetAgentId)) {
+        return {
+          status: "forbidden",
+          error: `agentId "${targetAgentId}" is not allowed for subagent spawning`
+        };
+      }
+    }
+    const childSessionKey = createSubagentSessionKey(targetAgentId);
+    const runId = crypto3.randomUUID();
+    const childRoomId = sessionKeyToRoomId(childSessionKey, targetAgentId);
+    const roomMetadata = {
+      isSubagent: true,
+      sessionKey: childSessionKey,
+      task: params.task,
+      spawnedAt: Date.now(),
+      cleanup: params.cleanup ?? "keep"
+    };
+    if (requesterContext.roomId)
+      roomMetadata.parentRoomId = requesterContext.roomId;
+    if (requesterContext.sessionKey)
+      roomMetadata.parentSessionKey = requesterContext.sessionKey;
+    if (params.label)
+      roomMetadata.label = params.label;
+    const childRoom = {
+      id: childRoomId,
+      name: params.label || `Subagent: ${params.task.slice(0, 50)}`,
+      source: "subagent",
+      type: ChannelType.SELF,
+      channelId: childSessionKey,
+      agentId: this.runtime.agentId,
+      worldId: this.runtime.agentId,
+      metadata: roomMetadata
+    };
+    await this.runtime.ensureRoomExists(childRoom);
+    const now2 = Date.now();
+    const archiveAfterMs = config.archiveAfterMinutes ? config.archiveAfterMinutes * 60000 : undefined;
+    const record = {
+      runId,
+      childSessionKey,
+      requesterSessionKey: requesterContext.sessionKey ?? "unknown",
+      requesterDisplayKey: requesterContext.sessionKey ?? "main",
+      task: params.task,
+      cleanup: params.cleanup ?? "keep",
+      createdAt: now2,
+      startedAt: now2,
+      cleanupHandled: false,
+      roomId: childRoomId,
+      worldId: this.runtime.agentId
+    };
+    const normalizedOrigin = normalizeDeliveryContext(requesterContext.origin);
+    if (normalizedOrigin)
+      record.requesterOrigin = normalizedOrigin;
+    if (params.label)
+      record.label = params.label;
+    if (archiveAfterMs)
+      record.archiveAtMs = now2 + archiveAfterMs;
+    this.subagentRuns.set(runId, record);
+    const spawnPayload = {
+      runId,
+      childSessionKey,
+      childRoomId,
+      task: params.task
+    };
+    if (requesterContext.sessionKey)
+      spawnPayload.requesterSessionKey = requesterContext.sessionKey;
+    if (requesterContext.roomId)
+      spawnPayload.requesterRoomId = requesterContext.roomId;
+    if (params.label)
+      spawnPayload.label = params.label;
+    this.emitSubagentEvent("SUBAGENT_SPAWN_REQUESTED", spawnPayload);
+    const systemPromptParams = {
+      childSessionKey,
+      task: params.task
+    };
+    if (requesterContext.sessionKey)
+      systemPromptParams.requesterSessionKey = requesterContext.sessionKey;
+    if (requesterContext.origin)
+      systemPromptParams.requesterOrigin = requesterContext.origin;
+    if (params.label)
+      systemPromptParams.label = params.label;
+    const systemPrompt = this.buildSubagentSystemPrompt(systemPromptParams);
+    const taskMetadata = {
+      isSubagentTask: true,
+      runId,
+      systemPromptOverride: systemPrompt
+    };
+    const modelOverride = params.model || config.model;
+    const thinkingOverride = params.thinking || config.thinking;
+    if (modelOverride)
+      taskMetadata.modelOverride = modelOverride;
+    if (thinkingOverride)
+      taskMetadata.thinkingOverride = thinkingOverride;
+    const initialMessage = {
+      id: hashToUUID(`${runId}-initial`),
+      entityId: this.runtime.agentId,
+      agentId: this.runtime.agentId,
+      roomId: childRoomId,
+      content: {
+        text: params.task,
+        type: "text",
+        metadata: taskMetadata
+      }
+    };
+    this.executeSubagentRun(runId, initialMessage, params.runTimeoutSeconds).catch((error) => {
+      this.runtime.logger.error(`Subagent execution error [runId=${runId}]: ${error}`);
+      this.handleSubagentError(runId, error);
     });
+    return {
+      status: "accepted",
+      childSessionKey,
+      childRoomId,
+      runId,
+      modelApplied: !!(params.model || config.model)
+    };
   }
-  async sendToRoom(roomId, content, options) {
-    const room = await this.runtime.getRoom(roomId);
-    if (!room) {
-      return {
-        success: false,
-        channel: "unknown",
-        targetId: roomId,
-        error: `Room not found: ${roomId}`
-      };
+  async executeSubagentRun(runId, initialMessage, timeoutSeconds) {
+    const config = this.getConfig();
+    const timeout = (timeoutSeconds ?? config.timeoutSeconds ?? 300) * 1000;
+    const controller = new AbortController;
+    this.activeRuns.set(runId, controller);
+    const timeoutId = timeout > 0 ? setTimeout(() => {
+      controller.abort();
+      this.handleSubagentTimeout(runId);
+    }, timeout) : null;
+    try {
+      await this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+        runtime: this.runtime,
+        message: initialMessage,
+        source: "subagent"
+      });
+      await this.waitForCompletion(runId, timeout, controller.signal);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      this.activeRuns.delete(runId);
     }
-    const metadata = room.metadata;
-    const channel = this.normalizeChannel(metadata?.messagingChannel);
-    const to = metadata?.messagingTo ?? room.channelId ?? "";
-    if (!to) {
-      return {
-        success: false,
-        channel,
-        targetId: roomId,
-        error: "Room has no messaging target configured"
-      };
+  }
+  async waitForCompletion(runId, timeoutMs, signal) {
+    const startTime = Date.now();
+    const pollInterval = 500;
+    while (!signal.aborted) {
+      const record = this.subagentRuns.get(runId);
+      if (!record) {
+        return;
+      }
+      if (record.endedAt) {
+        return;
+      }
+      if (Date.now() - startTime > timeoutMs + 5000) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
     }
-    return this.send({
-      target: {
-        channel,
-        to,
-        accountId: metadata?.messagingAccountId,
-        threadId: metadata?.messagingThreadId
-      },
-      content,
-      idempotencyKey: options?.idempotencyKey,
-      timeoutMs: options?.timeoutMs
+  }
+  handleSubagentTimeout(runId) {
+    const record = this.subagentRuns.get(runId);
+    if (!record || record.endedAt) {
+      return;
+    }
+    record.endedAt = Date.now();
+    record.outcome = { status: "timeout" };
+    const timeoutPayload = {
+      runId,
+      childSessionKey: record.childSessionKey,
+      task: record.task,
+      status: "timeout"
+    };
+    if (record.roomId)
+      timeoutPayload.childRoomId = record.roomId;
+    this.emitSubagentEvent("SUBAGENT_RUN_TIMEOUT", timeoutPayload);
+    this.announceSubagentResult(runId).catch((err) => {
+      this.runtime.logger.error(`Failed to announce timeout [runId=${runId}]: ${err}`);
     });
   }
-  async sendToSession(sessionKey, content, options) {
-    const agentId = extractAgentIdFromSessionKey(sessionKey);
-    const roomId = sessionKeyToRoomId(sessionKey, agentId);
-    return this.sendToRoom(roomId, content, options);
+  handleSubagentError(runId, error) {
+    const record = this.subagentRuns.get(runId);
+    if (!record) {
+      return;
+    }
+    record.endedAt = Date.now();
+    record.outcome = {
+      status: "error",
+      error: error instanceof Error ? error.message : String(error)
+    };
+    const errorPayload = {
+      runId,
+      childSessionKey: record.childSessionKey,
+      task: record.task,
+      status: "error"
+    };
+    if (record.outcome.error)
+      errorPayload.error = record.outcome.error;
+    if (record.roomId)
+      errorPayload.childRoomId = record.roomId;
+    this.emitSubagentEvent("SUBAGENT_RUN_FAILED", errorPayload);
+    this.announceSubagentResult(runId).catch((err) => {
+      this.runtime.logger.error(`Failed to announce error [runId=${runId}]: ${err}`);
+    });
   }
-  async sendViaDiscord(params) {
-    const discordService = this.runtime.getService("DISCORD");
-    if (!discordService?.client) {
-      return {
-        success: false,
-        channel: "discord",
-        targetId: params.target.to,
-        error: "Discord service not available"
-      };
+  async handleRunEnded(payload) {
+    const p = payload;
+    if (!p.roomId) {
+      return;
     }
-    try {
-      const channel = await discordService.client.channels.fetch(params.target.to);
-      if (!channel?.send) {
-        return {
-          success: false,
-          channel: "discord",
-          targetId: params.target.to,
-          error: "Channel not found or not a text channel"
+    for (const [runId, record] of this.subagentRuns.entries()) {
+      if (record.roomId === p.roomId && !record.endedAt) {
+        record.endedAt = Date.now();
+        record.outcome = { status: "ok" };
+        const completedPayload = {
+          runId,
+          childSessionKey: record.childSessionKey,
+          childRoomId: record.roomId,
+          task: record.task,
+          status: "completed",
+          endedAt: record.endedAt,
+          durationMs: record.endedAt - (record.startedAt ?? record.createdAt)
         };
+        if (record.startedAt)
+          completedPayload.startedAt = record.startedAt;
+        this.emitSubagentEvent("SUBAGENT_RUN_COMPLETED", completedPayload);
+        await this.announceSubagentResult(runId);
+        break;
       }
-      const message = await channel.send({
-        content: params.content.text,
-        ...params.target.replyToMessageId ? { reply: { messageReference: params.target.replyToMessageId } } : {}
-      });
-      return {
-        success: true,
-        messageId: message.id,
-        channel: "discord",
-        targetId: params.target.to,
-        sentAt: Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        channel: "discord",
-        targetId: params.target.to,
-        error: error instanceof Error ? error.message : String(error)
-      };
     }
   }
-  async sendViaTelegram(params) {
-    const telegramService = this.runtime.getService("TELEGRAM");
-    if (!telegramService?.bot?.telegram) {
-      return {
-        success: false,
-        channel: "telegram",
-        targetId: params.target.to,
-        error: "Telegram service not available"
-      };
+  async handleRunTimeout(payload) {
+    const p = payload;
+    if (!p.roomId) {
+      return;
     }
-    try {
-      const chatId = Number.isNaN(Number(params.target.to)) ? params.target.to : Number(params.target.to);
-      const result = await telegramService.bot.telegram.sendMessage(chatId, params.content.text, {
-        reply_to_message_id: params.target.replyToMessageId ? Number(params.target.replyToMessageId) : undefined,
-        disable_web_page_preview: params.content.disableLinkPreview,
-        disable_notification: params.content.silent
-      });
-      return {
-        success: true,
-        messageId: String(result.message_id),
-        channel: "telegram",
-        targetId: params.target.to,
-        sentAt: Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        channel: "telegram",
-        targetId: params.target.to,
-        error: error instanceof Error ? error.message : String(error)
-      };
+    for (const [runId, record] of this.subagentRuns.entries()) {
+      if (record.roomId === p.roomId && !record.endedAt) {
+        this.handleSubagentTimeout(runId);
+        break;
+      }
     }
   }
-  async sendViaSlack(params) {
-    const slackService = this.runtime.getService("slack");
-    if (!slackService?.sendMessage) {
-      return {
-        success: false,
-        channel: "slack",
-        targetId: params.target.to,
-        error: "Slack service not available or sendMessage method not found"
-      };
+  async announceSubagentResult(runId) {
+    const record = this.subagentRuns.get(runId);
+    if (!record) {
+      return false;
     }
-    try {
-      const result = await slackService.sendMessage(params.target.to, params.content.text, {
-        threadTs: params.target.threadId ? String(params.target.threadId) : undefined,
-        replyBroadcast: false
-      });
-      return {
-        success: true,
-        messageId: result.ts,
-        channel: "slack",
-        targetId: params.target.to,
-        sentAt: Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        channel: "slack",
-        targetId: params.target.to,
-        error: error instanceof Error ? error.message : String(error)
-      };
+    if (record.cleanupCompletedAt || record.cleanupHandled) {
+      return false;
     }
-  }
-  async sendViaWhatsApp(params) {
-    const whatsappService = this.runtime.getService("whatsapp");
-    if (!whatsappService?.sendText) {
-      return {
-        success: false,
-        channel: "whatsapp",
-        targetId: params.target.to,
-        error: "WhatsApp service not available or sendText method not found"
-      };
+    record.cleanupHandled = true;
+    let reply;
+    if (record.roomId) {
+      const memories = await this.runtime.getMemories({
+        tableName: "messages",
+        roomId: record.roomId,
+        count: 10
+      });
+      const lastAssistant = memories.filter((m) => m.entityId === this.runtime.agentId).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0];
+      reply = lastAssistant?.content?.text;
     }
-    try {
-      const result = await whatsappService.sendText(params.target.to, params.content.text);
-      const messageId = result.messages?.[0]?.id;
-      return {
-        success: true,
-        messageId,
-        channel: "whatsapp",
-        targetId: params.target.to,
-        sentAt: Date.now()
+    const durationMs = record.endedAt ? record.endedAt - (record.startedAt ?? record.createdAt) : undefined;
+    const statsLine = `Runtime: ${formatDurationShort(durationMs) ?? "n/a"} • Session: ${record.childSessionKey}`;
+    const outcome = record.outcome ?? { status: "unknown" };
+    const statusLabel = outcome.status === "ok" ? "completed successfully" : outcome.status === "timeout" ? "timed out" : outcome.status === "error" ? `failed: ${outcome.error || "unknown error"}` : "finished with unknown status";
+    const taskLabel = record.label || record.task || "background task";
+    const triggerMessage = [
+      `A background task "${taskLabel}" just ${statusLabel}.`,
+      "",
+      "Findings:",
+      reply || "(no output)",
+      "",
+      statsLine,
+      "",
+      "Summarize this naturally for the user. Keep it brief (1-2 sentences).",
+      "Do not mention technical details like tokens, stats, or that this was a background task.",
+      "You can respond with NO_REPLY if no announcement is needed."
+    ].join(`
+`);
+    if (record.requesterSessionKey && record.requesterSessionKey !== "unknown") {
+      const requesterRoomId = sessionKeyToRoomId(record.requesterSessionKey, extractAgentIdFromSessionKey(record.requesterSessionKey));
+      const metadata = {
+        isSubagentAnnouncement: true,
+        subagentRunId: runId
       };
-    } catch (error) {
-      return {
-        success: false,
-        channel: "whatsapp",
-        targetId: params.target.to,
-        error: error instanceof Error ? error.message : String(error)
+      if (record.requesterOrigin) {
+        metadata.deliveryContext = record.requesterOrigin;
+      }
+      const announceMessage = {
+        id: hashToUUID(`${runId}-announce`),
+        entityId: this.runtime.agentId,
+        agentId: this.runtime.agentId,
+        roomId: requesterRoomId,
+        content: {
+          text: triggerMessage,
+          type: "text",
+          metadata
+        }
       };
+      await this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+        runtime: this.runtime,
+        message: announceMessage,
+        source: "subagent_announce"
+      });
     }
+    const announcePayload = {
+      runId,
+      childSessionKey: record.childSessionKey,
+      task: record.task,
+      outcome
+    };
+    if (record.requesterSessionKey)
+      announcePayload.requesterSessionKey = record.requesterSessionKey;
+    this.emitSubagentEvent("SUBAGENT_ANNOUNCE_SENT", announcePayload);
+    record.cleanupCompletedAt = Date.now();
+    if (record.cleanup === "delete") {
+      this.subagentRuns.delete(runId);
+    }
+    return true;
   }
-  async sendViaTwitch(params) {
-    const twitchService = this.runtime.getService("twitch");
-    if (!twitchService?.sendMessage) {
+  buildSubagentSystemPrompt(params) {
+    const taskText = typeof params.task === "string" && params.task.trim() ? params.task.replace(/\s+/g, " ").trim() : "{{TASK_DESCRIPTION}}";
+    const lines = [
+      "# Subagent Context",
+      "",
+      "You are a **subagent** spawned by the main agent for a specific task.",
+      "",
+      "## Your Role",
+      `- You were created to handle: ${taskText}`,
+      "- Complete this task. That's your entire purpose.",
+      "- You are NOT the main agent. Don't try to be.",
+      "",
+      "## Rules",
+      "1. **Stay focused** - Do your assigned task, nothing else",
+      "2. **Complete the task** - Your final message will be automatically reported to the main agent",
+      "3. **Don't initiate** - No heartbeats, no proactive actions, no side quests",
+      "4. **Be ephemeral** - You may be terminated after task completion. That's fine.",
+      "",
+      "## Output Format",
+      "When complete, your final response should include:",
+      "- What you accomplished or found",
+      "- Any relevant details the main agent should know",
+      "- Keep it concise but informative",
+      "",
+      "## What You DON'T Do",
+      "- NO user conversations (that's main agent's job)",
+      "- NO external messages unless explicitly tasked with a specific recipient",
+      "- NO cron jobs or persistent state",
+      "- NO pretending to be the main agent",
+      "",
+      "## Session Context",
+      params.label ? `- Label: ${params.label}` : undefined,
+      params.requesterSessionKey ? `- Requester session: ${params.requesterSessionKey}` : undefined,
+      params.requesterOrigin?.channel ? `- Requester channel: ${params.requesterOrigin.channel}` : undefined,
+      `- Your session: ${params.childSessionKey}`,
+      ""
+    ].filter((line) => line !== undefined);
+    return lines.join(`
+`);
+  }
+  async sendToAgent(params, requesterContext) {
+    const runId = crypto3.randomUUID();
+    const policy = this.getAgentToAgentPolicy();
+    let targetSessionKey = params.sessionKey;
+    if (!targetSessionKey && params.label) {
+      const matchingRun = this.findSubagentRunByLabel(params.label, params.agentId);
+      if (matchingRun) {
+        targetSessionKey = matchingRun.childSessionKey;
+      } else {
+        return {
+          status: "error",
+          runId,
+          error: `No subagent found with label "${params.label}"`
+        };
+      }
+    }
+    if (!targetSessionKey) {
       return {
-        success: false,
-        channel: "twitch",
-        targetId: params.target.to,
-        error: "Twitch service not available or sendMessage method not found"
+        status: "error",
+        runId,
+        error: "Either sessionKey or label is required"
       };
     }
-    try {
-      const result = await twitchService.sendMessage(params.content.text, {
-        channel: params.target.to,
-        replyTo: params.target.replyToMessageId
+    const requesterAgentId = requesterContext.sessionKey ? extractAgentIdFromSessionKey(requesterContext.sessionKey) : this.runtime.character?.name ?? "unknown";
+    const targetAgentId = extractAgentIdFromSessionKey(targetSessionKey);
+    if (requesterAgentId !== targetAgentId) {
+      if (!policy.enabled) {
+        return {
+          status: "forbidden",
+          runId,
+          error: "Agent-to-agent messaging is disabled. Set settings.agentToAgent.enabled=true to allow cross-agent sends."
+        };
+      }
+      if (!policy.isAllowed(requesterAgentId, targetAgentId)) {
+        return {
+          status: "forbidden",
+          runId,
+          error: "Agent-to-agent messaging denied by policy."
+        };
+      }
+    }
+    const targetRoomId = sessionKeyToRoomId(targetSessionKey, targetAgentId);
+    const a2aContextParams = {
+      targetSessionKey
+    };
+    if (requesterContext.sessionKey)
+      a2aContextParams.requesterSessionKey = requesterContext.sessionKey;
+    const contextMessage = this.buildAgentToAgentContext(a2aContextParams);
+    const a2aMetadata = {
+      isAgentToAgent: true,
+      runId,
+      systemPromptOverride: contextMessage
+    };
+    if (requesterContext.sessionKey)
+      a2aMetadata.senderSessionKey = requesterContext.sessionKey;
+    if (requesterContext.roomId)
+      a2aMetadata.senderRoomId = requesterContext.roomId;
+    const message = {
+      id: hashToUUID(`${runId}-a2a`),
+      entityId: this.runtime.agentId,
+      agentId: this.runtime.agentId,
+      roomId: targetRoomId,
+      content: {
+        text: params.message,
+        type: "text",
+        metadata: a2aMetadata
+      }
+    };
+    const timeoutMs = (params.timeoutSeconds ?? 30) * 1000;
+    if (params.timeoutSeconds === 0) {
+      this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+        runtime: this.runtime,
+        message,
+        source: "a2a"
+      }).catch((err) => {
+        this.runtime.logger.error(`A2A send error [runId=${runId}]: ${err}`);
       });
-      return {
-        success: result.success,
-        messageId: result.messageId,
-        channel: "twitch",
-        targetId: params.target.to,
-        sentAt: Date.now()
+      const asyncPayload = {
+        runId,
+        childSessionKey: targetSessionKey,
+        task: params.message
       };
-    } catch (error) {
+      if (requesterContext.sessionKey)
+        asyncPayload.requesterSessionKey = requesterContext.sessionKey;
+      this.emitSubagentEvent("A2A_MESSAGE_SENT", asyncPayload);
       return {
-        success: false,
-        channel: "twitch",
-        targetId: params.target.to,
-        error: error instanceof Error ? error.message : String(error)
+        status: "accepted",
+        runId,
+        sessionKey: targetSessionKey,
+        delivery: { status: "pending", mode: "async" }
       };
     }
-  }
-  async sendViaInternal(params) {
-    const roomId = params.target.to;
-    const messageId = crypto3.randomUUID();
-    try {
-      const memory = {
-        id: messageId,
-        entityId: this.runtime.agentId,
-        agentId: this.runtime.agentId,
-        roomId,
-        content: {
-          text: params.content.text,
-          type: "text",
-          source: "internal",
-          metadata: {
-            isInternalMessage: true,
-            idempotencyKey: params.idempotencyKey
-          }
-        },
-        createdAt: Date.now()
-      };
-      await this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
-        runtime: this.runtime,
-        message: memory,
-        source: "internal_messaging"
+    const sentAt = Date.now();
+    await this.runtime.emitEvent(EventType2.MESSAGE_RECEIVED, {
+      runtime: this.runtime,
+      message,
+      source: "a2a"
+    });
+    const pollIntervalMs = 500;
+    const maxPolls = Math.ceil(timeoutMs / pollIntervalMs);
+    let lastReply;
+    for (let poll = 0;poll < maxPolls; poll++) {
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+      const memories = await this.runtime.getMemories({
+        tableName: "messages",
+        roomId: targetRoomId,
+        count: 10
       });
+      const newReplies = memories.filter((m) => m.entityId === this.runtime.agentId && m.id !== message.id && m.createdAt && m.createdAt > sentAt);
+      if (newReplies.length > 0) {
+        lastReply = newReplies.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))[0];
+        break;
+      }
+    }
+    const syncPayload = {
+      runId,
+      childSessionKey: targetSessionKey,
+      task: params.message
+    };
+    if (requesterContext.sessionKey)
+      syncPayload.requesterSessionKey = requesterContext.sessionKey;
+    this.emitSubagentEvent("A2A_MESSAGE_SENT", syncPayload);
+    if (!lastReply) {
       return {
-        success: true,
-        messageId,
-        channel: "internal",
-        targetId: params.target.to,
-        sentAt: Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        channel: "internal",
-        targetId: params.target.to,
-        error: error instanceof Error ? error.message : String(error)
+        status: "timeout",
+        runId,
+        sessionKey: targetSessionKey,
+        error: `No response received within ${params.timeoutSeconds ?? 30} seconds`,
+        delivery: { status: "timeout", mode: "sync" }
       };
     }
+    const result = {
+      status: "ok",
+      runId,
+      sessionKey: targetSessionKey,
+      delivery: { status: "delivered", mode: "sync" }
+    };
+    if (lastReply.content?.text)
+      result.reply = lastReply.content.text;
+    return result;
   }
-  normalizeChannel(channel) {
-    if (!channel) {
-      return "unknown";
-    }
-    const lower = channel.toLowerCase();
-    if (lower === "discord" || lower.includes("discord")) {
-      return "discord";
-    }
-    if (lower === "telegram" || lower.includes("telegram")) {
-      return "telegram";
-    }
-    if (lower === "slack" || lower.includes("slack")) {
-      return "slack";
-    }
-    if (lower === "whatsapp" || lower.includes("whatsapp")) {
-      return "whatsapp";
-    }
-    if (lower === "twitch" || lower.includes("twitch")) {
-      return "twitch";
+  buildAgentToAgentContext(params) {
+    return [
+      "# Agent-to-Agent Message Context",
+      "",
+      "This message was sent by another agent session.",
+      params.requesterSessionKey ? `- Sender: ${params.requesterSessionKey}` : undefined,
+      `- Target: ${params.targetSessionKey}`,
+      "",
+      "Process this message and respond appropriately."
+    ].filter((l) => l !== undefined).join(`
+`);
+  }
+  getSubagentRun(runId) {
+    return this.subagentRuns.get(runId);
+  }
+  findSubagentRunByLabel(label, agentId) {
+    const normalizedLabel = label.toLowerCase().trim();
+    const normalizedAgentId = agentId ? normalizeAgentId2(agentId) : undefined;
+    for (const run of this.subagentRuns.values()) {
+      const runLabel = run.label?.toLowerCase().trim();
+      if (runLabel !== normalizedLabel) {
+        continue;
+      }
+      if (normalizedAgentId) {
+        const runAgentId = extractAgentIdFromSessionKey(run.childSessionKey);
+        if (normalizeAgentId2(runAgentId) !== normalizedAgentId) {
+          continue;
+        }
+      }
+      if (!run.endedAt) {
+        return run;
+      }
     }
-    if (lower === "google_chat" || lower.includes("google") || lower.includes("gchat")) {
-      return "google_chat";
+    const completedRuns = [...this.subagentRuns.values()].filter((run) => {
+      const runLabel = run.label?.toLowerCase().trim();
+      if (runLabel !== normalizedLabel) {
+        return false;
+      }
+      if (normalizedAgentId) {
+        const runAgentId = extractAgentIdFromSessionKey(run.childSessionKey);
+        if (normalizeAgentId2(runAgentId) !== normalizedAgentId) {
+          return false;
+        }
+      }
+      return true;
+    }).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+    return completedRuns[0];
+  }
+  listSubagentRuns(requesterSessionKey) {
+    const runs = [...this.subagentRuns.values()];
+    if (!requesterSessionKey) {
+      return runs;
     }
-    if (lower === "internal" || lower === "a2a") {
-      return "internal";
+    return runs.filter((r) => r.requesterSessionKey === requesterSessionKey);
+  }
+  cancelSubagentRun(runId) {
+    const controller = this.activeRuns.get(runId);
+    if (controller) {
+      controller.abort();
+      return true;
     }
-    return "unknown";
+    return false;
   }
   on(event, handler) {
     this.emitter.on(event, handler);
@@ -3597,25 +3685,46 @@ class MessagingService extends Service4 {
   off(event, handler) {
     this.emitter.off(event, handler);
   }
-  emitMessagingEvent(type, payload) {
+  emitSubagentEvent(type, payload) {
     this.emitter.emit(type, payload);
-    this.emitter.emit("messaging", { type, ...payload });
+    this.emitter.emit("task", { type, ...payload });
+  }
+  startSweeper() {
+    if (this.sweeper) {
+      return;
+    }
+    this.sweeper = setInterval(() => {
+      this.sweepOldRuns();
+    }, 60000);
+    this.sweeper.unref?.();
+  }
+  sweepOldRuns() {
+    const now2 = Date.now();
+    for (const [runId, record] of this.subagentRuns.entries()) {
+      if (record.archiveAtMs && record.archiveAtMs <= now2) {
+        this.subagentRuns.delete(runId);
+      }
+    }
   }
   async stop() {
-    this.pendingDeliveries.clear();
+    if (this.sweeper) {
+      clearInterval(this.sweeper);
+      this.sweeper = null;
+    }
+    for (const controller of this.activeRuns.values()) {
+      controller.abort();
+    }
+    this.activeRuns.clear();
     this.emitter.removeAllListeners();
   }
 }
-// src/types/subagent.ts
-var SubagentEventType = {
-  SPAWN_REQUESTED: "SUBAGENT_SPAWN_REQUESTED",
-  RUN_STARTED: "SUBAGENT_RUN_STARTED",
-  RUN_COMPLETED: "SUBAGENT_RUN_COMPLETED",
-  RUN_FAILED: "SUBAGENT_RUN_FAILED",
-  RUN_TIMEOUT: "SUBAGENT_RUN_TIMEOUT",
-  ANNOUNCE_SENT: "SUBAGENT_ANNOUNCE_SENT",
-  A2A_MESSAGE_SENT: "A2A_MESSAGE_SENT",
-  A2A_MESSAGE_RECEIVED: "A2A_MESSAGE_RECEIVED"
+// src/types/messaging.ts
+var MessagingEventType = {
+  SEND_REQUESTED: "MESSAGING_SEND_REQUESTED",
+  SENT: "MESSAGING_SENT",
+  SEND_FAILED: "MESSAGING_SEND_FAILED",
+  DELIVERED: "MESSAGING_DELIVERED",
+  READ: "MESSAGING_READ"
 };
 // src/types/sandbox.ts
 var SandboxEventType = {
@@ -3627,13 +3736,16 @@ var SandboxEventType = {
   BROWSER_STARTED: "SANDBOX_BROWSER_STARTED",
   BROWSER_STOPPED: "SANDBOX_BROWSER_STOPPED"
 };
-// src/types/messaging.ts
-var MessagingEventType = {
-  SEND_REQUESTED: "MESSAGING_SEND_REQUESTED",
-  SENT: "MESSAGING_SENT",
-  SEND_FAILED: "MESSAGING_SEND_FAILED",
-  DELIVERED: "MESSAGING_DELIVERED",
-  READ: "MESSAGING_READ"
+// src/types/subagent.ts
+var SubagentEventType = {
+  SPAWN_REQUESTED: "SUBAGENT_SPAWN_REQUESTED",
+  RUN_STARTED: "SUBAGENT_RUN_STARTED",
+  RUN_COMPLETED: "SUBAGENT_RUN_COMPLETED",
+  RUN_FAILED: "SUBAGENT_RUN_FAILED",
+  RUN_TIMEOUT: "SUBAGENT_RUN_TIMEOUT",
+  ANNOUNCE_SENT: "SUBAGENT_ANNOUNCE_SENT",
+  A2A_MESSAGE_SENT: "A2A_MESSAGE_SENT",
+  A2A_MESSAGE_RECEIVED: "A2A_MESSAGE_RECEIVED"
 };
 // index.ts
 var sessionProviders = getSessionProviders2();
@@ -3748,4 +3860,4 @@ export {
   AgentOrchestratorService
 };
 
-//# debugId=9695C525D670EDC964756E2164756E21
+//# debugId=4AD40853FB59A54864756E2164756E21