plugin-agent-orchestrator 1.0.13 → 1.0.15

package/dist/server/tools/delegate-task.js

@@ -26,30 +26,72 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var delegate_task_exports = {};
 __export(delegate_task_exports, {
-  createDelegateToolsProvider: () => createDelegateToolsProvider
+  createDelegateToolsProvider: () => createDelegateToolsProvider,
+  invalidateDelegateToolsCache: () => invalidateDelegateToolsCache
 });
 module.exports = __toCommonJS(delegate_task_exports);
 var import_zod = require("zod");
+var import_crypto = require("crypto");
 var import_prebuilt = require("@langchain/langgraph/prebuilt");
 var import_tools = require("@langchain/core/tools");
 var import_messages = require("@langchain/core/messages");
+var import_ExecutionSpanService = require("../services/ExecutionSpanService");
 const ORCHESTRATOR_DEPTH_KEY = "__orchestratorDepth";
+const MAX_DISPATCH_CONCURRENCY = 5;
+const MAX_DISPATCH_TASKS = 20;
+const MAX_TOOL_NAME_LENGTH = 64;
 function sanitizeToolPart(value) {
   return (value || "").replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function buildDelegateToolName(leaderUsername, subAgentUsername) {
   return `delegate_${sanitizeToolPart(leaderUsername)}_to_${sanitizeToolPart(subAgentUsername)}`;
 }
-function isDelegateToolName(toolName) {
-  return toolName.startsWith("delegate_to_") || toolName.startsWith("delegate_") && toolName.includes("_to_");
+function buildDispatchToolName(leaderUsername) {
+  return `dispatch_subagents_${sanitizeToolPart(leaderUsername)}`;
+}
+function createRootRunId(seed = "") {
+  const hash = (0, import_crypto.createHash)("sha1").update(`${Date.now()}::${Math.random()}::${seed}`).digest("hex").slice(0, 10);
+  return `run_${Date.now()}_${hash}`;
+}
+let registeredDelegateNamesByPlugin = /* @__PURE__ */ new WeakMap();
+function isDelegateToolName(plugin, toolName) {
+  var _a;
+  return ((_a = registeredDelegateNamesByPlugin.get(plugin)) == null ? void 0 : _a.has(toolName)) ?? false;
+}
+async function runWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (cursor < items.length) {
+      const i = cursor;
+      cursor += 1;
+      results[i] = await fn(items[i], i);
+    }
+  });
+  await Promise.all(workers);
+  return results;
 }
 function createDelegateToolOptions(plugin, options) {
-  const { leaderUsername, subAgentUsername, subAgentEmployee, maxDepth, timeout, toolName, legacyAlias, llmService, model } = options;
+  const {
+    leaderUsername,
+    subAgentUsername,
+    subAgentEmployee,
+    maxDepth,
+    timeout,
+    toolName,
+    legacyAlias,
+    llmService,
+    model,
+    recursionLimit
+  } = options;
+  const dispatchToolName = buildDispatchToolName(leaderUsername);
   const toolDescription = [
     `Delegate a task from "${leaderUsername}" to the AI Employee "${subAgentEmployee.nickname || subAgentUsername}".`,
     legacyAlias ? "This is a backward-compatible alias for existing skill assignments." : "",
     subAgentEmployee.about ? `Specialist profile: ${subAgentEmployee.about.substring(0, 200)}` : "",
-    "The sub-agent will execute the task independently and return its final answer."
+    "The sub-agent will execute the task independently and return its final answer.",
+    `For multiple INDEPENDENT sub-tasks, prefer "${dispatchToolName}" to fan-out in one call (up to ${MAX_DISPATCH_CONCURRENCY} run in parallel), or emit several delegate_* calls in the SAME assistant turn so they run concurrently.`
   ].filter(Boolean).join(" ");
   return {
     scope: "CUSTOM",
@@ -69,7 +111,25 @@ function createDelegateToolOptions(plugin, options) {
       })
     },
     invoke: async (ctx, args, id) => {
-      const callingEmployee = resolveCallingEmployee(ctx);
+      const callingEmployee = await resolveCallingEmployee(ctx, plugin);
+      if (!callingEmployee) {
+        await logDelegation(ctx, plugin, {
+          leaderUsername,
+          subAgentUsername,
+          toolName,
+          task: args.task,
+          context: args.context,
+          result: "",
+          status: "error",
+          depth: ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0,
+          durationMs: 0,
+          error: `Cannot determine calling AI employee for delegation tool "${toolName}".`
+        });
+        return {
+          status: "error",
+          content: `Cannot determine calling AI employee for "${toolName}". Start the request from an AI Employee conversation so leader scoping can be enforced.`
+        };
+      }
       if (callingEmployee && callingEmployee !== leaderUsername) {
         await logDelegation(ctx, plugin, {
           leaderUsername,
@@ -99,16 +159,205 @@ function createDelegateToolOptions(plugin, options) {
         toolCallId: id,
         toolName,
         llmService,
-        model
+        model,
+        recursionLimit
       });
     }
   };
 }
-function resolveCallingEmployee(ctx) {
-  var _a, _b, _c;
-  const raw = ctx._currentAIEmployee || ((_a = ctx.state) == null ? void 0 : _a.currentAIEmployee) || ((_c = (_b = ctx.runtime) == null ? void 0 : _b.context) == null ? void 0 : _c.currentAIEmployee);
+function formatDispatchResults(results, rulesBySubAgent) {
+  var _a;
+  const total = results.length;
+  const ok = results.filter((r) => r.status === "success").length;
+  const lines = [
+    `Dispatched ${total} sub-task(s) \u2014 ${ok} succeeded, ${total - ok} failed (max ${MAX_DISPATCH_CONCURRENCY} ran in parallel).`,
+    ""
+  ];
+  for (const r of results) {
+    const employee = (_a = rulesBySubAgent.get(r.subAgent)) == null ? void 0 : _a.employee;
+    const displayName = (employee == null ? void 0 : employee.nickname) || r.subAgent;
+    const dur = `${(r.durationMs / 1e3).toFixed(1)}s`;
+    lines.push(`--- [${r.index + 1}] ${displayName} (${r.subAgent}) [${r.status}] (${dur}) ---`);
+    lines.push(r.content || "(empty)");
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function createDispatchToolOptions(plugin, options) {
+  const { leaderUsername, rulesBySubAgent } = options;
+  const toolName = buildDispatchToolName(leaderUsername);
+  const subAgentNames = Array.from(rulesBySubAgent.keys());
+  const subAgentList = subAgentNames.map((username) => {
+    var _a, _b;
+    const entry = rulesBySubAgent.get(username);
+    if (!entry) return `- ${username}`;
+    const profile = ((_a = entry.employee) == null ? void 0 : _a.about) ? ` \u2014 ${String(entry.employee.about).substring(0, 120)}` : "";
+    const display = ((_b = entry.employee) == null ? void 0 : _b.nickname) ? ` (${entry.employee.nickname})` : "";
+    return `- ${username}${display}${profile}`;
+  }).join("\n");
+  const description = [
+    `Dispatch multiple tasks from "${leaderUsername}" to its configured sub-agents in one call.`,
+    `At most ${MAX_DISPATCH_CONCURRENCY} sub-tasks run in parallel; up to ${MAX_DISPATCH_TASKS} tasks per call.`,
+    "Use this when you have already planned independent sub-tasks and want to fan-out, then aggregate the results.",
+    `Available sub-agents:
+${subAgentList}`
+  ].join(" ");
+  return {
+    scope: "CUSTOM",
+    execution: "backend",
+    defaultPermission: "ALLOW",
+    silence: false,
+    introduction: {
+      title: `[${leaderUsername}] Dispatch sub-agents`,
+      about: description
+    },
+    definition: {
+      name: toolName,
+      description,
+      schema: import_zod.z.object({
+        tasks: import_zod.z.array(
+          import_zod.z.object({
+            subAgent: import_zod.z.enum(subAgentNames).describe("Username of the sub-agent that should execute this task."),
+            task: import_zod.z.string().describe("Detailed task description for the sub-agent."),
+            context: import_zod.z.string().optional().describe("Optional additional context for the sub-agent.")
+          })
+        ).min(1).max(MAX_DISPATCH_TASKS).describe(`List of sub-tasks to dispatch concurrently. Up to ${MAX_DISPATCH_CONCURRENCY} run in parallel.`)
+      })
+    },
+    invoke: async (ctx, args, id) => {
+      var _a;
+      const callingEmployee = await resolveCallingEmployee(ctx, plugin);
+      if (!callingEmployee) {
+        const distinctSubs = Array.from(new Set((args.tasks ?? []).map((t) => t.subAgent).filter(Boolean)));
+        const reportedSub = distinctSubs.length === 1 ? distinctSubs[0] : "(multiple)";
+        await logDelegation(ctx, plugin, {
+          leaderUsername,
+          subAgentUsername: reportedSub,
+          toolName,
+          task: truncateText(args.tasks ?? [], 2e3),
+          result: "",
+          status: "error",
+          depth: ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0,
+          durationMs: 0,
+          error: `Cannot determine calling AI employee for dispatch tool "${toolName}". Targets: ${distinctSubs.join(", ") || "(empty)"}.`
+        });
+        return {
+          status: "error",
+          content: `Cannot determine calling AI employee for "${toolName}". Start the request from an AI Employee conversation so leader scoping can be enforced.`
+        };
+      }
+      if (callingEmployee && callingEmployee !== leaderUsername) {
+        const distinctSubs = Array.from(new Set((args.tasks ?? []).map((t) => t.subAgent).filter(Boolean)));
+        const reportedSub = distinctSubs.length === 1 ? distinctSubs[0] : "(multiple)";
+        await logDelegation(ctx, plugin, {
+          leaderUsername,
+          subAgentUsername: reportedSub,
+          toolName,
+          task: truncateText(args.tasks ?? [], 2e3),
+          result: "",
+          status: "error",
+          depth: ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0,
+          durationMs: 0,
+          error: `Employee "${callingEmployee}" is not authorized to dispatch sub-agents for leader "${leaderUsername}". Targets: ${distinctSubs.join(", ") || "(empty)"}.`
+        });
+        return {
+          status: "error",
+          content: `Employee "${callingEmployee}" is not authorized to dispatch sub-agents for leader "${leaderUsername}".`
+        };
+      }
+      const tasks = args.tasks ?? [];
+      if (!tasks.length) {
+        return {
+          status: "error",
+          content: "No tasks provided. Pass at least one item in `tasks`."
+        };
+      }
+      const dispatchRootRunId = ((_a = (0, import_ExecutionSpanService.getOrchestratorTraceContext)(ctx)) == null ? void 0 : _a.rootRunId) || createRootRunId(`${leaderUsername}:dispatch`);
+      const results = await runWithConcurrency(tasks, MAX_DISPATCH_CONCURRENCY, async (item, i) => {
+        const startedAt = Date.now();
+        const entry = rulesBySubAgent.get(item.subAgent);
+        if (!entry) {
+          return {
+            index: i,
+            subAgent: item.subAgent,
+            status: "error",
+            content: `Unknown sub-agent "${item.subAgent}". Allowed: ${subAgentNames.join(", ")}.`,
+            durationMs: 0
+          };
+        }
+        try {
+          const res = await invokeDelegateTask(ctx, plugin, {
+            leaderUsername,
+            subAgentUsername: item.subAgent,
+            subAgentEmployee: entry.employee,
+            task: item.task,
+            context: item.context,
+            maxDepth: entry.rule.maxDepth ?? 1,
+            timeout: entry.rule.timeout ?? 12e4,
+            toolCallId: `${id}-${i}`,
+            toolName,
+            llmService: entry.rule.llmService,
+            model: entry.rule.model,
+            recursionLimit: entry.rule.recursionLimit,
+            rootRunId: dispatchRootRunId
+          });
+          return {
+            index: i,
+            subAgent: item.subAgent,
+            status: res.status,
+            content: res.content,
+            durationMs: Date.now() - startedAt
+          };
+        } catch (e) {
+          return {
+            index: i,
+            subAgent: item.subAgent,
+            status: "error",
+            content: (e == null ? void 0 : e.message) || String(e),
+            durationMs: Date.now() - startedAt
+          };
+        }
+      });
+      const successCount = results.filter((r) => r.status === "success").length;
+      return {
+        status: successCount > 0 ? "success" : "error",
+        content: formatDispatchResults(results, rulesBySubAgent)
+      };
+    }
+  };
+}
+function captureCtxSnapshot(ctx) {
+  var _a, _b, _c, _d;
+  let userId;
+  try {
+    userId = ((_b = (_a = ctx.auth) == null ? void 0 : _a.user) == null ? void 0 : _b.id) || ((_d = (_c = ctx.state) == null ? void 0 : _c.currentUser) == null ? void 0 : _d.id);
+  } catch {
+  }
+  return { userId };
+}
+function normalizeEmployeeUsername(raw) {
   if (!raw) return null;
-  return typeof raw === "string" ? raw : raw.username;
+  if (typeof raw === "string") return raw;
+  return raw.username || raw.aiEmployeeUsername || raw.name || null;
+}
+async function resolveCallingEmployee(ctx, plugin) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const values = ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) || {};
+  const raw = ctx._currentAIEmployee || ((_c = ctx.state) == null ? void 0 : _c.currentAIEmployee) || ((_e = (_d = ctx.runtime) == null ? void 0 : _d.context) == null ? void 0 : _e.currentAIEmployee) || values.aiEmployee;
+  const direct = normalizeEmployeeUsername(raw);
+  if (direct) return direct;
+  const sessionId = values.sessionId || ((_g = (_f = ctx.action) == null ? void 0 : _f.params) == null ? void 0 : _g.sessionId);
+  if (!sessionId) return null;
+  try {
+    const repo = ((_i = (_h = ctx.db) == null ? void 0 : _h.getRepository) == null ? void 0 : _i.call(_h, "aiConversations")) || plugin.db.getRepository("aiConversations");
+    const conversation = await repo.findOne({
+      filter: { sessionId }
+    });
+    return normalizeEmployeeUsername((conversation == null ? void 0 : conversation.aiEmployeeUsername) || ((_j = conversation == null ? void 0 : conversation.get) == null ? void 0 : _j.call(conversation, "aiEmployeeUsername")));
+  } catch (e) {
+    plugin.app.log.warn(`[AgentOrchestrator] Failed to resolve AI employee for session "${sessionId}"`, e);
+    return null;
+  }
 }
 function truncateText(value, maxLen) {
   const text = typeof value === "string" ? value : value == null ? "" : JSON.stringify(value);
@@ -118,77 +367,211 @@ function truncateText(value, maxLen) {
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function hasModelSettings(value) {
+  return Boolean((value == null ? void 0 : value.llmService) && (value == null ? void 0 : value.model));
+}
+const TOOLS_CACHE_TTL_MS = 3e4;
+let toolsCacheByPlugin = /* @__PURE__ */ new WeakMap();
+let hooksAttached = null;
+function attachInvalidationHooks(plugin) {
+  if (!hooksAttached) hooksAttached = /* @__PURE__ */ new WeakSet();
+  if (hooksAttached.has(plugin)) return;
+  hooksAttached.add(plugin);
+  const invalidate = () => {
+    toolsCacheByPlugin.delete(plugin);
+    registeredDelegateNamesByPlugin.delete(plugin);
+  };
+  plugin.db.on("orchestratorConfig.afterCreate", invalidate);
+  plugin.db.on("orchestratorConfig.afterUpdate", invalidate);
+  plugin.db.on("orchestratorConfig.afterDestroy", invalidate);
+  plugin.db.on("aiEmployees.afterCreate", invalidate);
+  plugin.db.on("aiEmployees.afterUpdate", invalidate);
+  plugin.db.on("aiEmployees.afterDestroy", invalidate);
+}
+async function buildDelegateTools(plugin) {
+  const configRepo = plugin.db.getRepository("orchestratorConfig");
+  if (!configRepo) {
+    registeredDelegateNamesByPlugin.set(plugin, /* @__PURE__ */ new Set());
+    return [];
+  }
+  const configs = await configRepo.find({
+    filter: { enabled: true }
+  });
+  if (!(configs == null ? void 0 : configs.length)) {
+    registeredDelegateNamesByPlugin.set(plugin, /* @__PURE__ */ new Set());
+    return [];
+  }
+  const employeeCache = /* @__PURE__ */ new Map();
+  const tools = [];
+  const generatedNames = /* @__PURE__ */ new Map();
+  const configsBySubAgent = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    const items = configsBySubAgent.get(config.subAgentUsername) || [];
+    items.push(config);
+    configsBySubAgent.set(config.subAgentUsername, items);
+  }
+  for (const config of configs) {
+    const { leaderUsername, subAgentUsername, maxDepth, timeout, recursionLimit } = config;
+    let subAgentEmployee = employeeCache.get(subAgentUsername);
+    if (!subAgentEmployee) {
+      subAgentEmployee = await plugin.db.getRepository("aiEmployees").findOne({
+        filter: { username: subAgentUsername }
+      });
+      if (subAgentEmployee) {
+        employeeCache.set(subAgentUsername, subAgentEmployee);
+      }
+    }
+    if (!subAgentEmployee) continue;
+    const toolName = buildDelegateToolName(leaderUsername, subAgentUsername);
+    if (toolName.length > MAX_TOOL_NAME_LENGTH) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Tool name "${toolName}" exceeds the ${MAX_TOOL_NAME_LENGTH}-char limit enforced by most LLM providers. Skipping rule (${leaderUsername} \u2192 ${subAgentUsername}). Shorten one of the usernames.`
+      );
+      continue;
+    }
+    const existing = generatedNames.get(toolName);
+    if (existing) {
+      const suffix = (0, import_crypto.createHash)("sha1").update(`${leaderUsername}::${subAgentUsername}`).digest("hex").slice(0, 6);
+      plugin.app.log.error(
+        `[AgentOrchestrator] Tool-name collision: rule (${leaderUsername} \u2192 ${subAgentUsername}) sanitizes to "${toolName}", same as (${existing.leader} \u2192 ${existing.sub}). Skipping duplicate registration. Rename one of the usernames or apply suffix "_${suffix}" manually.`
+      );
+      continue;
+    }
+    generatedNames.set(toolName, { leader: leaderUsername, sub: subAgentUsername });
+    tools.push(
+      createDelegateToolOptions(plugin, {
+        leaderUsername,
+        subAgentUsername,
+        subAgentEmployee,
+        maxDepth,
+        timeout,
+        toolName,
+        llmService: config.llmService,
+        model: config.model,
+        recursionLimit
+      })
+    );
+  }
+  for (const [subAgentUsername, items] of configsBySubAgent.entries()) {
+    if (items.length !== 1) {
+      const leaders = items.map((c) => c.leaderUsername).join(", ");
+      plugin.app.log.warn(
+        `[AgentOrchestrator] Legacy alias "delegate_to_${sanitizeToolPart(
+          subAgentUsername
+        )}" is NOT registered for sub-agent "${subAgentUsername}" because it has multiple leaders (${leaders}). Leaders must use the per-rule "delegate_<leader>_to_<sub>" tool name.`
+      );
+      continue;
+    }
+    const config = items[0];
+    const subAgentEmployee = employeeCache.get(subAgentUsername);
+    if (!subAgentEmployee) continue;
+    const legacyToolName = `delegate_to_${sanitizeToolPart(subAgentUsername)}`;
+    if (legacyToolName.length > MAX_TOOL_NAME_LENGTH) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Legacy alias "${legacyToolName}" exceeds the ${MAX_TOOL_NAME_LENGTH}-char limit. Skipping alias for sub-agent "${subAgentUsername}".`
+      );
+      continue;
+    }
+    const aliasExisting = generatedNames.get(legacyToolName);
+    if (aliasExisting) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Legacy alias "${legacyToolName}" collides with another rule (${aliasExisting.leader} \u2192 ${aliasExisting.sub}). Skipping alias registration.`
+      );
+      continue;
+    }
+    generatedNames.set(legacyToolName, {
+      leader: config.leaderUsername,
+      sub: subAgentUsername
+    });
+    tools.push(
+      createDelegateToolOptions(plugin, {
+        leaderUsername: config.leaderUsername,
+        subAgentUsername,
+        subAgentEmployee,
+        maxDepth: config.maxDepth,
+        timeout: config.timeout,
+        toolName: legacyToolName,
+        legacyAlias: true,
+        llmService: config.llmService,
+        model: config.model,
+        recursionLimit: config.recursionLimit
+      })
+    );
+  }
+  const rulesByLeader = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    const subAgentEmployee = employeeCache.get(config.subAgentUsername);
+    if (!subAgentEmployee) continue;
+    let bucket = rulesByLeader.get(config.leaderUsername);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      rulesByLeader.set(config.leaderUsername, bucket);
+    }
+    bucket.set(config.subAgentUsername, { rule: config, employee: subAgentEmployee });
+  }
+  for (const [leaderUsername, rulesBySubAgent] of rulesByLeader.entries()) {
+    if (!rulesBySubAgent.size) continue;
+    const dispatchToolName = buildDispatchToolName(leaderUsername);
+    if (dispatchToolName.length > MAX_TOOL_NAME_LENGTH) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Dispatch tool "${dispatchToolName}" exceeds the ${MAX_TOOL_NAME_LENGTH}-char limit. Skipping for leader "${leaderUsername}".`
+      );
+      continue;
+    }
+    const dispatchExisting = generatedNames.get(dispatchToolName);
+    if (dispatchExisting) {
+      plugin.app.log.error(
+        `[AgentOrchestrator] Dispatch tool "${dispatchToolName}" collides with another generated tool (${dispatchExisting.leader} \u2192 ${dispatchExisting.sub}). Skipping dispatch registration for leader "${leaderUsername}".`
+      );
+      continue;
+    }
+    generatedNames.set(dispatchToolName, { leader: leaderUsername, sub: "(dispatch)" });
+    tools.push(createDispatchToolOptions(plugin, { leaderUsername, rulesBySubAgent }));
+  }
+  registeredDelegateNamesByPlugin.set(plugin, new Set(generatedNames.keys()));
+  return tools;
+}
 function createDelegateToolsProvider(plugin) {
+  attachInvalidationHooks(plugin);
   return async (register) => {
     try {
-      const configRepo = plugin.db.getRepository("orchestratorConfig");
-      if (!configRepo) return;
-      const configs = await configRepo.find({
-        filter: { enabled: true }
-      });
-      if (!(configs == null ? void 0 : configs.length)) return;
-      const employeeCache = /* @__PURE__ */ new Map();
-      const tools = [];
-      const configsBySubAgent = /* @__PURE__ */ new Map();
-      for (const config of configs) {
-        const items = configsBySubAgent.get(config.subAgentUsername) || [];
-        items.push(config);
-        configsBySubAgent.set(config.subAgentUsername, items);
+      let toolsCache = toolsCacheByPlugin.get(plugin);
+      if (!toolsCache || toolsCache.expiresAt <= Date.now()) {
+        const tools = await buildDelegateTools(plugin);
+        toolsCache = { tools, expiresAt: Date.now() + TOOLS_CACHE_TTL_MS };
+        toolsCacheByPlugin.set(plugin, toolsCache);
       }
-      for (const config of configs) {
-        const { leaderUsername, subAgentUsername, maxDepth, timeout } = config;
-        let subAgentEmployee = employeeCache.get(subAgentUsername);
-        if (!subAgentEmployee) {
-          subAgentEmployee = await plugin.db.getRepository("aiEmployees").findOne({
-            filter: { username: subAgentUsername }
-          });
-          if (subAgentEmployee) {
-            employeeCache.set(subAgentUsername, subAgentEmployee);
-          }
-        }
-        if (!subAgentEmployee) continue;
-        const toolName = buildDelegateToolName(leaderUsername, subAgentUsername);
-        tools.push(createDelegateToolOptions(plugin, {
-          leaderUsername,
-          subAgentUsername,
-          subAgentEmployee,
-          maxDepth,
-          timeout,
-          toolName,
-          llmService: config.llmService,
-          model: config.model
-        }));
-      }
-      for (const [subAgentUsername, items] of configsBySubAgent.entries()) {
-        if (items.length !== 1) continue;
-        const config = items[0];
-        const subAgentEmployee = employeeCache.get(subAgentUsername);
-        if (!subAgentEmployee) continue;
-        const legacyToolName = `delegate_to_${sanitizeToolPart(subAgentUsername)}`;
-        if (tools.some((tool) => tool.definition.name === legacyToolName)) continue;
-        tools.push(createDelegateToolOptions(plugin, {
-          leaderUsername: config.leaderUsername,
-          subAgentUsername,
-          subAgentEmployee,
-          maxDepth: config.maxDepth,
-          timeout: config.timeout,
-          toolName: legacyToolName,
-          legacyAlias: true,
-          llmService: config.llmService,
-          model: config.model
-        }));
-      }
-      if (tools.length) {
-        register.registerTools(tools);
+      if (toolsCache.tools.length) {
+        register.registerTools(toolsCache.tools);
       }
     } catch (e) {
       plugin.app.log.error("[AgentOrchestrator] Failed to register delegate tools", e);
     }
   };
 }
+function invalidateDelegateToolsCache() {
+  toolsCacheByPlugin = /* @__PURE__ */ new WeakMap();
+  registeredDelegateNamesByPlugin = /* @__PURE__ */ new WeakMap();
+}
 async function invokeDelegateTask(ctx, plugin, options) {
   var _a, _b, _c, _d, _e;
-  const { leaderUsername, subAgentUsername, subAgentEmployee, task, context, maxDepth, timeout, toolCallId, toolName, llmService, model } = options;
+  const {
+    leaderUsername,
+    subAgentUsername,
+    subAgentEmployee,
+    task,
+    context,
+    maxDepth,
+    timeout,
+    toolCallId,
+    toolName,
+    llmService,
+    model,
+    recursionLimit,
+    rootRunId: providedRootRunId,
+    parentSpanId: providedParentSpanId
+  } = options;
+  const ctxSnapshot = captureCtxSnapshot(ctx);
   const currentDepth = ctx[ORCHESTRATOR_DEPTH_KEY] ?? 0;
   if (currentDepth >= maxDepth) {
     await logDelegation(ctx, plugin, {
@@ -201,13 +584,18 @@ async function invokeDelegateTask(ctx, plugin, options) {
       status: "error",
       depth: currentDepth,
       durationMs: 0,
-      error: `Delegation depth limit reached (${currentDepth}/${maxDepth}).`
+      error: `Delegation depth limit reached (${currentDepth}/${maxDepth}).`,
+      snapshot: ctxSnapshot
     });
     return {
       status: "error",
       content: `Delegation depth limit reached (${currentDepth}/${maxDepth}). Sub-agent "${subAgentUsername}" cannot delegate further.`
     };
   }
+  const spanService = new import_ExecutionSpanService.ExecutionSpanService(plugin);
+  const upstreamTraceContext = (0, import_ExecutionSpanService.getOrchestratorTraceContext)(ctx);
+  const rootRunId = providedRootRunId || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.rootRunId) || createRootRunId(`${leaderUsername}:${subAgentUsername}`);
+  const parentSpanId = providedParentSpanId || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.spanId) || (upstreamTraceContext == null ? void 0 : upstreamTraceContext.parentSpanId);
   const startTime = Date.now();
   const trace = [
     {
@@ -217,6 +605,25 @@ async function invokeDelegateTask(ctx, plugin, options) {
       content: task
     }
   ];
+  const executionSpan = await spanService.create({
+    rootRunId,
+    parentSpanId,
+    type: "sub_agent",
+    status: "running",
+    leaderUsername,
+    employeeUsername: subAgentUsername,
+    title: `Delegation: ${leaderUsername} -> ${subAgentUsername}`,
+    input: { task, context },
+    metadata: {
+      depth: currentDepth,
+      maxDepth,
+      toolName,
+      recursionLimit,
+      llmOverride: llmService && model ? { llmService, model } : void 0
+    },
+    userId: ctxSnapshot.userId
+  });
+  const executionSpanId = (executionSpan == null ? void 0 : executionSpan.id) ? String(executionSpan.id) : void 0;
   const logRecord = await logDelegation(ctx, plugin, {
     leaderUsername,
     subAgentUsername,
@@ -227,25 +634,31 @@ async function invokeDelegateTask(ctx, plugin, options) {
     status: "running",
     depth: currentDepth,
     durationMs: 0,
-    trace
+    trace,
+    snapshot: ctxSnapshot
   });
+  if (executionSpanId && (logRecord == null ? void 0 : logRecord.id)) {
+    await spanService.update(executionSpanId, { orchestratorLogId: logRecord.id });
+  }
   try {
     const aiPlugin = ctx.app.pm.get("ai");
     if (!aiPlugin) {
       throw new Error("Plugin AI is not installed or enabled");
     }
-    let modelSettings = subAgentEmployee.modelSettings;
+    let modelSettings = hasModelSettings(subAgentEmployee.modelSettings) ? subAgentEmployee.modelSettings : void 0;
     if (llmService && model) {
       modelSettings = { llmService, model };
     }
-    if (!(modelSettings == null ? void 0 : modelSettings.llmService) || !(modelSettings == null ? void 0 : modelSettings.model)) {
+    if (!hasModelSettings(modelSettings)) {
       const leaderEmployee = await plugin.db.getRepository("aiEmployees").findOne({
         filter: { username: leaderUsername }
       });
       const dynamicModel = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.model;
-      modelSettings = (leaderEmployee == null ? void 0 : leaderEmployee.modelSettings) || dynamicModel;
-      if (!(modelSettings == null ? void 0 : modelSettings.llmService) || !(modelSettings == null ? void 0 : modelSettings.model)) {
-        throw new Error(`Sub-agent "${subAgentUsername}" has no LLM model configured (and leader fallback failed). Please configure a model in the Orchestrator Config or AI Employee settings.`);
+      modelSettings = hasModelSettings(leaderEmployee == null ? void 0 : leaderEmployee.modelSettings) ? leaderEmployee.modelSettings : hasModelSettings(dynamicModel) ? dynamicModel : void 0;
+      if (!hasModelSettings(modelSettings)) {
+        throw new Error(
+          `Sub-agent "${subAgentUsername}" has no LLM model configured (and leader fallback failed). Please configure a model in the Orchestrator Config or AI Employee settings.`
+        );
       }
     }
     const { provider } = await aiPlugin.aiManager.getLLMService({
@@ -255,22 +668,56 @@ async function invokeDelegateTask(ctx, plugin, options) {
     const chatModel = provider.createModel();
     const coreToolsManager = ctx.app.aiManager.toolsManager;
     const allTools = await coreToolsManager.listTools();
-    const employeeSkills = (((_d = subAgentEmployee.skillSettings) == null ? void 0 : _d.skills) ?? []).map((s) => typeof s === "string" ? s : s.name).filter(Boolean);
+    const employeeSkills = (((_d = subAgentEmployee.skillSettings) == null ? void 0 : _d.skills) ?? []).map(
+      (s) => typeof s === "string" ? { name: s, autoCall: false } : { name: s == null ? void 0 : s.name, autoCall: (s == null ? void 0 : s.autoCall) === true }
+    ).filter((s) => Boolean(s.name));
+    const employeeSkillMap = new Map(employeeSkills.map((skill) => [skill.name, skill]));
     const langchainTools = [];
     for (const toolEntry of allTools) {
-      const toolName2 = toolEntry.definition.name;
-      if (!toolName2) continue;
-      if (!employeeSkills.includes(toolName2) || isDelegateToolName(toolName2)) {
+      const entryName = toolEntry.definition.name;
+      if (!entryName) continue;
+      const employeeSkill = employeeSkillMap.get(entryName);
+      if (!employeeSkill || isDelegateToolName(plugin, entryName) || employeeSkill.autoCall !== true || toolEntry.defaultPermission !== "ALLOW") {
         continue;
       }
       langchainTools.push(
         new import_tools.DynamicStructuredTool({
-          name: toolName2.replace(/[^a-zA-Z0-9_-]/g, "_"),
-          description: toolEntry.definition.description || toolName2,
+          name: entryName.replace(/[^a-zA-Z0-9_-]/g, "_"),
+          description: toolEntry.definition.description || entryName,
           schema: toolEntry.definition.schema || import_zod.z.object({}),
           func: async (toolArgs) => {
+            var _a2;
             const invokeCtx = Object.create(ctx);
             invokeCtx[ORCHESTRATOR_DEPTH_KEY] = currentDepth + 1;
+            const toolStartedAt = Date.now();
+            const isSkillHubTool = entryName === "skill_hub_execute" || entryName.startsWith("skill_hub_");
+            const toolSpan = await spanService.create({
+              rootRunId,
+              parentSpanId: executionSpanId,
+              type: isSkillHubTool ? "skill" : "tool",
+              status: "running",
+              leaderUsername,
+              employeeUsername: subAgentUsername,
+              toolName: toolEntry.definition.name,
+              title: isSkillHubTool ? `Skill: ${toolEntry.definition.name}` : `Tool: ${toolEntry.definition.name}`,
+              input: toolArgs,
+              metadata: {
+                depth: currentDepth + 1,
+                toolCallId: `orch-${toolCallId}`,
+                defaultPermission: toolEntry.defaultPermission
+              },
+              userId: ctxSnapshot.userId
+            });
+            const toolSpanId = (toolSpan == null ? void 0 : toolSpan.id) ? String(toolSpan.id) : void 0;
+            (0, import_ExecutionSpanService.setOrchestratorTraceContext)(invokeCtx, {
+              rootRunId,
+              spanId: toolSpanId,
+              parentSpanId: executionSpanId,
+              toolCallId: `orch-${toolCallId}`,
+              leaderUsername,
+              employeeUsername: subAgentUsername,
+              toolName: toolEntry.definition.name
+            });
             trace.push({
               type: "tool_call",
               at: nowIso(),
@@ -280,17 +727,26 @@ async function invokeDelegateTask(ctx, plugin, options) {
             });
             try {
               const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
+              const output = truncateText((res == null ? void 0 : res.content) ?? (res == null ? void 0 : res.result) ?? res, 5e4);
               trace.push({
                 type: "tool_result",
                 at: nowIso(),
                 title: `Tool finished: ${toolEntry.definition.name}`,
                 toolName: toolEntry.definition.name,
                 status: (res == null ? void 0 : res.status) || "success",
-                content: truncateText((res == null ? void 0 : res.content) ?? res, 2e3)
+                content: truncateText(output, 2e3)
               });
               if ((res == null ? void 0 : res.status) === "error") {
+                await spanService.finish(toolSpanId, "error", toolStartedAt, {
+                  output,
+                  error: truncateText(res.content || output, 1e4)
+                });
                 throw new Error(`Tool <${toolEntry.definition.name}> failed: ${res.content}`);
               }
+              await spanService.finish(toolSpanId, "success", toolStartedAt, {
+                output,
+                skillExecutionId: ((_a2 = res == null ? void 0 : res.result) == null ? void 0 : _a2.execId) || (res == null ? void 0 : res.execId)
+              });
               return typeof (res == null ? void 0 : res.content) === "string" ? res.content : JSON.stringify(res);
             } catch (e) {
               trace.push({
@@ -301,6 +757,9 @@ async function invokeDelegateTask(ctx, plugin, options) {
                 status: "error",
                 content: e.message
               });
+              await spanService.finish(toolSpanId, "error", toolStartedAt, {
+                error: truncateText(e.message, 1e4)
+              });
               throw e;
             }
           }
@@ -317,11 +776,21 @@ async function invokeDelegateTask(ctx, plugin, options) {
 
 Context Provided:
 ${context}` : `Task: ${task}`;
-    const invokePromise = executeAgent(executor, systemPrompt, combinedTask, abortController.signal);
-    const result = await Promise.race([
-      invokePromise,
-      createTimeout(timeout, subAgentUsername, abortController)
-    ]);
+    const effectiveRecursionLimit = Number.isFinite(recursionLimit) && recursionLimit > 0 ? recursionLimit : 50;
+    const invokePromise = executeAgent(
+      executor,
+      systemPrompt,
+      combinedTask,
+      abortController.signal,
+      effectiveRecursionLimit
+    );
+    const timeoutHandle = createTimeout(timeout, subAgentUsername, abortController);
+    let result;
+    try {
+      result = await Promise.race([invokePromise, timeoutHandle.promise]);
+    } finally {
+      timeoutHandle.cancel();
+    }
     const content = result.content || "Sub-agent completed the task but produced no output.";
     trace.push({
       type: "finish",
@@ -342,7 +811,19 @@ ${context}` : `Task: ${task}`;
       depth: currentDepth,
       durationMs: Date.now() - startTime,
       trace,
-      messages: result.messages
+      messages: result.messages,
+      snapshot: ctxSnapshot
+    });
+    await spanService.finish(executionSpanId, "success", startTime, {
+      output: content,
+      metadata: {
+        depth: currentDepth,
+        maxDepth,
+        toolName,
+        recursionLimit,
+        messages: result.messages,
+        traceCount: trace.length
+      }
     });
     return {
       status: "success",
@@ -371,10 +852,21 @@ ${context}` : `Task: ${task}`;
           status: "error",
           content: e.message
         }
-      ]
+      ],
+      snapshot: ctxSnapshot
     }).catch((logErr) => {
       plugin.app.log.warn("[AgentOrchestrator] Failed to save error log for delegation", logErr);
     });
+    await spanService.finish(executionSpanId, "error", startTime, {
+      error: truncateText(e.message, 1e4),
+      metadata: {
+        depth: currentDepth,
+        maxDepth,
+        toolName,
+        recursionLimit,
+        traceCount: trace.length + 1
+      }
+    });
     return {
       status: "error",
       content: `Sub-agent "${subAgentUsername}" failed: ${e.message}`
@@ -382,17 +874,19 @@ ${context}` : `Task: ${task}`;
   }
 }
 async function logDelegation(ctx, plugin, data) {
-  var _a, _b, _c, _d, _e;
+  var _a, _b, _c, _d, _e, _f;
   try {
     const logsRepo = plugin.db.getRepository("orchestratorLogs");
     if (!logsRepo) {
       plugin.app.log.warn("[AgentOrchestrator] orchestratorLogs repository not found \u2014 skipping log");
       return;
     }
-    let userId;
-    try {
-      userId = ((_b = (_a = ctx.auth) == null ? void 0 : _a.user) == null ? void 0 : _b.id) || ((_d = (_c = ctx.state) == null ? void 0 : _c.currentUser) == null ? void 0 : _d.id);
-    } catch {
+    let userId = (_a = data.snapshot) == null ? void 0 : _a.userId;
+    if (userId == null) {
+      try {
+        userId = ((_c = (_b = ctx.auth) == null ? void 0 : _b.user) == null ? void 0 : _c.id) || ((_e = (_d = ctx.state) == null ? void 0 : _d.currentUser) == null ? void 0 : _e.id);
+      } catch {
+      }
     }
     const values = {
       leaderUsername: data.leaderUsername,
@@ -423,13 +917,13 @@ async function logDelegation(ctx, plugin, data) {
         createdAt: /* @__PURE__ */ new Date()
       }
     });
-    return ((_e = record == null ? void 0 : record.toJSON) == null ? void 0 : _e.call(record)) || record;
+    return ((_f = record == null ? void 0 : record.toJSON) == null ? void 0 : _f.call(record)) || record;
   } catch (e) {
     plugin.app.log.warn("[AgentOrchestrator] Failed to log delegation event", e);
   }
 }
-async function executeAgent(executor, systemPrompt, task, signal) {
-  const config = { recursionLimit: 50 };
+async function executeAgent(executor, systemPrompt, task, signal, recursionLimit = 50) {
+  const config = { recursionLimit };
   if (signal) {
     config.signal = signal;
   }
@@ -470,14 +964,22 @@ function serializeMessages(messages) {
   });
 }
 function createTimeout(ms, agentName, abortController) {
-  return new Promise(
-    (_, reject) => setTimeout(() => {
+  let timer;
+  const promise = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
       abortController == null ? void 0 : abortController.abort();
       reject(new Error(`Sub-agent "${agentName}" timed out after ${ms / 1e3}s`));
-    }, ms)
-  );
+    }, ms);
+  });
+  return {
+    promise,
+    cancel: () => {
+      if (timer) clearTimeout(timer);
+    }
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDelegateToolsProvider
+  createDelegateToolsProvider,
+  invalidateDelegateToolsCache
 });