@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/tools/send-task.ts

@@ -15,6 +15,7 @@ import {
   hasCapacity,
 } from "@/be/db";
 import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
+import { applyPreTaskCreate } from "@/extensions/apply-task-create";
 import { checkSlackRoutingCoherence } from "@/tasks/slack-routing";
 import { findDuplicateTask } from "@/tools/task-dedup";
 import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
@@ -28,6 +29,7 @@ import {
 import {
   type AgentTask,
   AssetKeySchema,
+  type CreateTaskOptions,
   FollowUpConfigSchema,
   ModelTierSchema,
   ReasoningEffortSchema,
@@ -69,7 +71,9 @@ export const sendTaskInputSchema = z
       .string()
       .max(200)
       .optional()
-      .describe("Optional routing context (maximum 200 characters)."),
+      .describe(
+        "Why this worker fits the task. Required when agentId is supplied: at least 10 characters after trimming whitespace, maximum 200 characters. Optional for implicit parent or pool routing.",
+      ),
     task: z.string().min(1).describe("The task description to send."),
     key: AssetKeySchema.optional().describe(
       "Logical namespace key. Child tasks inherit their parent namespace when provided.",
@@ -190,6 +194,14 @@ export const sendTaskInputSchema = z
         path: ["routingReason"],
       });
     }
+    if (data.agentId !== undefined && (data.routingNote?.trim().length ?? 0) < 10) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "routingNote is required when agentId is supplied (at least 10 characters after trim).",
+        path: ["routingNote"],
+      });
+    }
     checkOutputSchemaShape(data.outputSchema, ctx);
   });
 
@@ -269,6 +281,11 @@ export async function sendTaskHandler(
   if (agentId !== undefined && routingReason === undefined) {
     return toolErr("routingReason is required when agentId is supplied.");
   }
+  if (agentId !== undefined && (routingNote?.trim().length ?? 0) < 10) {
+    return toolErr(
+      "routingNote is required when agentId is supplied (at least 10 characters after trim).",
+    );
+  }
   if (ctx.kind === "owner" && !ctx.agentId) {
     return toolErr('Agent ID not found. The MCP client should define the "X-Agent-ID" header.', {
       data: { yourAgentId: ctx.agentId },
@@ -364,6 +381,55 @@ export async function sendTaskHandler(
   const effectiveRoutingReason =
     agentId !== undefined ? routingReason : effectiveAgentId ? "continuity" : undefined;
   const effectiveRoutingNote = effectiveRoutingReason ? routingNote : undefined;
+  const effectiveRoutingSource =
+    agentId !== undefined ? "declared" : effectiveAgentId ? "engine_default" : undefined;
+
+  const requestedTaskOptions: CreateTaskOptions = {
+    key: assetKey,
+    agentId: offerMode ? undefined : effectiveAgentId,
+    offeredTo: offerMode ? effectiveAgentId : undefined,
+    creatorAgentId,
+    requestedByUserId,
+    source: "mcp",
+    sourceTaskId,
+    taskType,
+    tags,
+    priority,
+    dependsOn,
+    dir,
+    parentTaskId: effectiveParentTaskId,
+    vcsRepo: effectiveVcsRepo,
+    model: normalizedModel.model,
+    modelTier: normalizedModel.modelTier,
+    effort,
+    slackChannelId,
+    slackThreadTs,
+    slackUserId,
+    overrideSlackContext,
+    followUpConfig,
+    outputSchema,
+    routingReason: effectiveRoutingReason,
+    routingSource: effectiveRoutingSource,
+    routingNote: effectiveRoutingNote,
+    routingAffinity:
+      effectiveLeadOnly || requiredCapabilities?.length
+        ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
+        : undefined,
+  };
+  const preCreate = await applyPreTaskCreate({
+    description: task,
+    options: requestedTaskOptions,
+    origin: "mcp",
+    requestInfo: ctx.kind === "owner" ? ctx.requestInfo : undefined,
+  });
+  if (preCreate.kind === "blocked") {
+    return toolErr(preCreate.reason, {
+      data: { yourAgentId: creatorAgentId },
+      details: JSON.stringify({ extension: preCreate.extension }),
+    });
+  }
+  const taskDescription = preCreate.description;
+  const taskOptions = preCreate.options;
 
   // The three dedup guards are pure reads, so they run twice: once here as a
   // fast path (keeping this tool's existing early-exit responses), and once
@@ -388,9 +454,9 @@ export async function sendTaskHandler(
     // Dedup guard: check for similar recent tasks
     if (!allowDuplicate && creatorAgentId) {
       const duplicate = await findDuplicateTask({
-        taskDescription: task,
-        creatorAgentId,
-        targetAgentId: effectiveAgentId ?? undefined,
+        taskDescription,
+        creatorAgentId: taskOptions.creatorAgentId ?? creatorAgentId,
+        targetAgentId: taskOptions.agentId ?? taskOptions.offeredTo,
       });
       if (duplicate) {
         return {
@@ -470,41 +536,13 @@ export async function sendTaskHandler(
     const raced = await evaluateDedupGuards();
     if (raced) return { success: raced.ok, message: raced.message, task: raced.task };
 
-    const finalTags = tags;
-
     // If no agentId (and no auto-routed agentId), create an unassigned task for the pool
-    if (!effectiveAgentId) {
-      const newTask = await createTaskExtended(task, {
-        key: assetKey,
-        creatorAgentId,
-        requestedByUserId,
-        sourceTaskId,
-        taskType,
-        tags: finalTags,
-        priority,
-        dependsOn,
-        dir,
-        parentTaskId: effectiveParentTaskId,
-        vcsRepo: effectiveVcsRepo,
-        model: normalizedModel.model,
-        modelTier: normalizedModel.modelTier,
-        effort,
-        slackChannelId,
-        slackThreadTs,
-        slackUserId,
-        overrideSlackContext,
-        followUpConfig,
-        outputSchema,
-        routingReason: effectiveRoutingReason,
-        routingNote: effectiveRoutingNote,
-        routingAffinity:
-          effectiveLeadOnly || requiredCapabilities?.length
-            ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
-            : undefined,
-      });
+    const targetAgentId = taskOptions.offeredTo ?? taskOptions.agentId ?? undefined;
+    if (!targetAgentId) {
+      const newTask = await createTaskExtended(taskDescription, taskOptions);
       await transferTrackerSyncToResumeChild({
-        parentTaskId: effectiveParentTaskId,
-        taskType,
+        parentTaskId: taskOptions.parentTaskId,
+        taskType: taskOptions.taskType,
         child: newTask,
       });
 
@@ -515,16 +553,16 @@ export async function sendTaskHandler(
       };
     }
 
-    const agent = await getAgentById(effectiveAgentId);
+    const agent = await getAgentById(targetAgentId);
 
     if (!agent) {
       return {
         success: false,
-        message: `Agent with ID "${effectiveAgentId}" not found.`,
+        message: `Agent with ID "${targetAgentId}" not found.`,
       };
     }
 
-    if (effectiveLeadOnly && !agent.isLead) {
+    if (taskOptions.routingAffinity?.leadOnly && !agent.isLead) {
       return {
         success: false,
         message: `Lead-only task requires a Lead agent; "${agent.name}" is not a Lead.`,
@@ -532,48 +570,20 @@ export async function sendTaskHandler(
     }
 
     // For direct assignment (not offer), check if agent has capacity
-    if (!offerMode && !(await hasCapacity(effectiveAgentId))) {
-      const activeCount = await getActiveTaskCount(effectiveAgentId);
+    if (!taskOptions.offeredTo && !(await hasCapacity(targetAgentId))) {
+      const activeCount = await getActiveTaskCount(targetAgentId);
       return {
         success: false,
         message: `Agent "${agent.name}" is at capacity (${activeCount}/${agent.maxTasks ?? 1} tasks). Use offerMode: true to offer the task instead, or wait for a task to complete.`,
       };
     }
 
-    if (offerMode) {
+    if (taskOptions.offeredTo) {
       // Offer the task to the agent (they must accept/reject)
-      const newTask = await createTaskExtended(task, {
-        key: assetKey,
-        offeredTo: effectiveAgentId,
-        creatorAgentId,
-        requestedByUserId,
-        sourceTaskId,
-        taskType,
-        tags: finalTags,
-        priority,
-        dependsOn,
-        dir,
-        parentTaskId: effectiveParentTaskId,
-        vcsRepo: effectiveVcsRepo,
-        model: normalizedModel.model,
-        modelTier: normalizedModel.modelTier,
-        effort,
-        slackChannelId,
-        slackThreadTs,
-        slackUserId,
-        overrideSlackContext,
-        followUpConfig,
-        outputSchema,
-        routingReason: effectiveRoutingReason,
-        routingNote: effectiveRoutingNote,
-        routingAffinity:
-          effectiveLeadOnly || requiredCapabilities?.length
-            ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
-            : undefined,
-      });
+      const newTask = await createTaskExtended(taskDescription, taskOptions);
       await transferTrackerSyncToResumeChild({
-        parentTaskId: effectiveParentTaskId,
-        taskType,
+        parentTaskId: taskOptions.parentTaskId,
+        taskType: taskOptions.taskType,
         child: newTask,
       });
 
@@ -585,38 +595,10 @@ export async function sendTaskHandler(
     }
 
     // Direct assignment
-    const newTask = await createTaskExtended(task, {
-      key: assetKey,
-      agentId: effectiveAgentId,
-      creatorAgentId,
-      requestedByUserId,
-      sourceTaskId,
-      taskType,
-      tags: finalTags,
-      priority,
-      dependsOn,
-      dir,
-      parentTaskId: effectiveParentTaskId,
-      vcsRepo: effectiveVcsRepo,
-      model: normalizedModel.model,
-      modelTier: normalizedModel.modelTier,
-      effort,
-      slackChannelId,
-      slackThreadTs,
-      slackUserId,
-      overrideSlackContext,
-      followUpConfig,
-      outputSchema,
-      routingReason: effectiveRoutingReason,
-      routingNote: effectiveRoutingNote,
-      routingAffinity:
-        effectiveLeadOnly || requiredCapabilities?.length
-          ? { leadOnly: effectiveLeadOnly, capabilities: requiredCapabilities ?? [] }
-          : undefined,
-    });
+    const newTask = await createTaskExtended(taskDescription, taskOptions);
     await transferTrackerSyncToResumeChild({
-      parentTaskId: effectiveParentTaskId,
-      taskType,
+      parentTaskId: taskOptions.parentTaskId,
+      taskType: taskOptions.taskType,
       child: newTask,
     });
 

package/src/tools/skills/skill-publish.ts

@@ -72,6 +72,7 @@ To reject: close this task with a rejection reason.`;
       const task = await createTaskExtended(taskDescription, {
         agentId: leadAgent.id,
         routingReason: "skill",
+        routingSource: "engine_default",
         creatorAgentId: requestInfo.agentId,
         source: "mcp",
         taskType: "skill-approval",

package/src/tools/store-progress.ts

@@ -102,7 +102,7 @@ export const registerStoreProgressTool = (server: McpServer) => {
           .string()
           .optional()
           .describe(
-            "The task result (used when completing). For Slack-originated tasks, this is published verbatim in the thread's outcome card: provide a concrete summary scaled to what was asked, including only the outcome and any links or IDs the human needs—not process narration, a transcript, or a restatement of the brief.",
+            "The task result (used when completing). For Slack-originated tasks, this is published verbatim in the thread's outcome card. Keep free-text output under 120 words by default. Name the result and every artifact link, plus any IDs the human needs. Link documents instead of inlining them; omit process narration, transcripts, and restatements of the brief. Exceed the target only when requested depth, enumerated results, essential evidence, caveats, or instructions require it, or when the task's outputSchema requires longer output. When the task carries an outputSchema, output must be JSON matching it.",
           ),
         failureReason: z
           .string()

package/src/tools/task-action.ts

@@ -28,6 +28,7 @@ import {
   updateTaskClaudeSessionId,
 } from "@/be/db";
 import { touchRuntimeInstance } from "@/be/multi-runtime";
+import { applyPreTaskCreate } from "@/extensions/apply-task-create";
 import { assertOwnsTask, ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import {
   createToolRegistrar,
@@ -39,6 +40,7 @@ import {
 import {
   AssetKeySchema,
   BudgetRefusalCauseSchema,
+  type CreateTaskOptions,
   ModelTierSchema,
   ReasoningEffortSchema,
   splitLegacyModelAlias,
@@ -265,7 +267,14 @@ export async function taskActionHandler(
 
   const agentId = ctx.agentId;
   let assetKey: string | undefined;
+  let preparedCreate: { description: string; options: CreateTaskOptions } | undefined;
   if (action === "create") {
+    if (!task) {
+      return taskActionResult(
+        { success: false, message: "Task description is required for 'create' action." },
+        agentId,
+      );
+    }
     try {
       assetKey = key
         ? await authorizeAssetKeyWrite(key, await resolveTaskAuditUserId(ctx.sourceTaskId, agentId))
@@ -279,33 +288,45 @@ export async function taskActionHandler(
             : String(error);
       return taskActionResult({ success: false, message }, agentId);
     }
+
+    const preCreate = await applyPreTaskCreate({
+      description: task,
+      options: {
+        key: assetKey,
+        creatorAgentId: agentId,
+        source: "mcp",
+        taskType,
+        tags,
+        priority,
+        dependsOn,
+        dir,
+        model: normalizedModel.model,
+        modelTier: normalizedModel.modelTier,
+        effort: input.effort,
+        routingAffinity:
+          leadOnly || requiredCapabilities?.length
+            ? { leadOnly, capabilities: requiredCapabilities ?? [] }
+            : undefined,
+      },
+      origin: "mcp",
+      requestInfo: ctx.requestInfo,
+    });
+    if (preCreate.kind === "blocked") {
+      return taskActionResult({ success: false, message: preCreate.reason }, agentId);
+    }
+    preparedCreate = {
+      description: preCreate.description,
+      options: preCreate.options,
+    };
   }
 
   const result = await getDbClient().transaction(async (): Promise<TaskActionResult> => {
     switch (action) {
       case "create": {
-        if (!task) {
-          return {
-            success: false,
-            message: "Task description is required for 'create' action.",
-          };
-        }
-        const newTask = await createTaskExtended(task, {
-          key: assetKey,
-          creatorAgentId: agentId,
-          taskType,
-          tags,
-          priority,
-          dependsOn,
-          dir,
-          model: normalizedModel.model,
-          modelTier: normalizedModel.modelTier,
-          effort: input.effort,
-          routingAffinity:
-            leadOnly || requiredCapabilities?.length
-              ? { leadOnly, capabilities: requiredCapabilities ?? [] }
-              : undefined,
-        });
+        const newTask = await createTaskExtended(
+          preparedCreate!.description,
+          preparedCreate!.options,
+        );
         return {
           success: true,
           message: `Created unassigned task "${newTask.id}".`,

package/src/tools/task-tool-ctx.ts

@@ -9,6 +9,7 @@ export type ToolCtx =
       runtimeInstanceId?: string;
       sourceTaskId?: string;
       sessionId?: string;
+      requestInfo?: RequestInfo;
     }
   | { kind: "user"; userId: string; user: User; sessionId?: string };
 
@@ -19,6 +20,7 @@ export function ownerCtx(info: RequestInfo): ToolCtx {
     runtimeInstanceId: info.runtimeInstanceId,
     sourceTaskId: info.sourceTaskId,
     sessionId: info.sessionId,
+    requestInfo: info,
   };
 }
 

package/src/tools/templates.ts

@@ -198,6 +198,7 @@ Use the crashed agent's identity above as context for who was on it and what kin
 Dispatch via \`send-task\` with ALL of:
 - an explicit \`agentId\` (the chosen worker) — REQUIRED. If you omit it, \`send-task\` auto-routes to the original task's agent, which is the dead worker, and the work re-strands.
 - \`routingReason: "reroute_fault"\`
+- \`routingNote\`: explain why this worker is the right recovery target (at least 10 characters after trim, maximum 200)
 - \`taskType: "resume"\`
 - the tag \`resume-generation:{{generation_next}}\`
 - \`parentTaskId: {{original_task_id}}\`
@@ -252,7 +253,7 @@ Required capabilities: {{required_capabilities}}{{artifacts_block}}
 
 This task has been sitting unassigned because no currently-registered agent matches its required role/capabilities. Pick an agent to take this work over and RE-DELEGATE it — do NOT execute it yourself.
 
-Dispatch via \`send-task\` with an explicit \`agentId\` (REQUIRED — omitting it re-pools the work under the same affinity tag and it will starve again), \`routingReason: "overflow"\`, and \`parentTaskId: {{original_task_id}}\`.
+Dispatch via \`send-task\` with an explicit \`agentId\` (REQUIRED — omitting it re-pools the work under the same affinity tag and it will starve again), \`routingReason: "overflow"\`, a \`routingNote\` explaining the worker choice (at least 10 characters after trim, maximum 200), and \`parentTaskId: {{original_task_id}}\`.
 
 This work will NOT fall back to the unassigned pool — you are the only re-delegation path.`,
   variables: [

package/src/tools/tool-config.ts

@@ -197,13 +197,15 @@ export const DEFERRED_TOOLS = new Set([
   "room-reset",
   "room-decode",
 
-  // Reusable scripts (6)
+  // Reusable scripts and extensions (8)
   "script-upsert",
   "script-delete",
   "script-apis",
   "launch-script-run",
   "get-script-run",
   "list-script-runs",
+  "extension-install",
+  "extension-list",
 
   // External command routes (1)
   "swarm_x",

package/src/tools/utils.ts

@@ -5,6 +5,11 @@ import type {
   ShapeOutput,
   ZodRawShapeCompat,
 } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import {
+  getParseErrorMessage,
+  normalizeObjectSchema,
+  safeParseAsync,
+} from "@modelcontextprotocol/sdk/server/zod-compat.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type {
   CallToolResult,
@@ -23,12 +28,18 @@ import { scrubObject, scrubSecrets } from "../utils/secret-scrubber";
 type Meta = RequestHandlerExtra<ServerRequest, ServerNotification>;
 
 const scriptSdkRequestOrigins = new WeakSet<object>();
+const extensionRequestOrigins = new WeakSet<object>();
 
 export function markScriptSdkRequestOrigin<T extends object>(meta: T): T {
   scriptSdkRequestOrigins.add(meta);
   return meta;
 }
 
+export function markExtensionRequestOrigin<T extends object>(meta: T): T {
+  extensionRequestOrigins.add(meta);
+  return meta;
+}
+
 export type RequestInfo = {
   sessionId: string | undefined;
   agentId: string | undefined;
@@ -36,7 +47,7 @@ export type RequestInfo = {
   runtimeInstanceId: string | undefined;
   sourceTaskId: string | undefined;
   contextKey: string | undefined;
-  callOrigin: "mcp" | "script-sdk";
+  callOrigin: "mcp" | "script-sdk" | "extension";
 };
 
 export const getRequestInfo = (req: Meta): RequestInfo => {
@@ -73,7 +84,11 @@ export const getRequestInfo = (req: Meta): RequestInfo => {
     runtimeInstanceId: typeof runtimeInstanceId === "string" ? runtimeInstanceId : undefined,
     sourceTaskId,
     contextKey,
-    callOrigin: scriptSdkRequestOrigins.has(req) ? "script-sdk" : "mcp",
+    callOrigin: extensionRequestOrigins.has(req)
+      ? "extension"
+      : scriptSdkRequestOrigins.has(req)
+        ? "script-sdk"
+        : "mcp",
   };
 };
 
@@ -622,7 +637,7 @@ const ctxControlMiddleware: FinalizeMiddleware = async (result, ctx) => {
   // Calls made through ctx.swarm.* execute inside a script sandbox, so their
   // response never enters the model's context. The script SDK has a separate,
   // much higher hard response limit to protect the sandbox heap.
-  if (ctx.callOrigin === "script-sdk") return result;
+  if (ctx.callOrigin === "script-sdk" || ctx.callOrigin === "extension") return result;
   if (CTX_CONTROL_EXEMPT_TOOLS.has(ctx.toolName)) return result;
 
   const fullWire = composeWireResult(result);
@@ -770,6 +785,85 @@ export function setPreloadedTools(server: McpServer, names: readonly string[]):
   preloadedToolsByServer.set(server, new Set(names));
 }
 
+type ExtensionDispatcher = typeof import("../extensions/dispatcher");
+
+async function applyPreToolCall(
+  name: string,
+  args: unknown,
+  requestInfo: RequestInfo,
+  inputSchema?: AnySchema | ZodRawShapeCompat,
+): Promise<{
+  args: unknown;
+  blocked?: SwarmToolResult;
+  dispatcher?: ExtensionDispatcher;
+}> {
+  if (requestInfo.callOrigin !== "mcp") return { args };
+
+  const dispatcher = await import("../extensions/dispatcher");
+  const result = await dispatcher.dispatchPre(
+    "pre.tool.call",
+    { tool: name, args, requestInfo },
+    inputSchema
+      ? {
+          validateModify: async (data) => {
+            const schema = normalizeObjectSchema(inputSchema) ?? inputSchema;
+            const parsed = await safeParseAsync(schema as AnySchema, data.args);
+            if (parsed.success) return { success: true, data: { args: parsed.data } };
+
+            const message = scrubSecrets(getParseErrorMessage(parsed.error));
+            console.warn(
+              `[extensions] Ignored invalid arguments from pre.tool.call for ${name}: ${message}`,
+            );
+            return {
+              success: false,
+              error: new Error(`Modified arguments for tool "${name}" are invalid: ${message}`),
+            };
+          },
+        }
+      : {
+          transformModify: ({ extension }) => {
+            const message = scrubSecrets(
+              `[extensions] Ignored pre.tool.call argument rewrite for tool "${name}" from extension "${extension.name}" because the tool has no input schema`,
+            );
+            console.warn(message);
+            throw new Error(message);
+          },
+        },
+  );
+
+  if (result.action === "block") {
+    return {
+      args,
+      blocked: toolErr(result.reason, {
+        details: `Extension "${result.extension.name}" rejected this tool call.`,
+      }),
+      dispatcher,
+    };
+  }
+  return {
+    args: inputSchema && result.action === "modify" ? result.data.args : args,
+    dispatcher,
+  };
+}
+
+function dispatchPostToolCall(
+  dispatcher: ExtensionDispatcher | undefined,
+  name: string,
+  args: unknown,
+  outcome: SwarmToolResult,
+  requestInfo: RequestInfo,
+  durationMs: number,
+): void {
+  if (!dispatcher) return;
+  void dispatcher.dispatchPost("post.tool.call", {
+    tool: name,
+    args,
+    result: outcome,
+    requestInfo,
+    durationMs,
+  });
+}
+
 /**
  * Creates a tool registration helper that automatically extracts request info
  * and passes it as the second parameter to the callback.
@@ -806,13 +900,24 @@ export const createToolRegistrar = (server: McpServer) => {
         return withSpan(
           "mcp.tool",
           async (span) => {
-            const outcome = await (
-              cb as (
-                requestInfo: RequestInfo,
-                meta: Meta,
-              ) => SwarmToolResult | Promise<SwarmToolResult>
-            )(requestInfo, meta);
+            const pre = await applyPreToolCall(name, {}, requestInfo);
+            let durationMs = 0;
+            let outcome = pre.blocked;
+            if (!outcome) {
+              const startedAt = Date.now();
+              try {
+                outcome = await (
+                  cb as (
+                    requestInfo: RequestInfo,
+                    meta: Meta,
+                  ) => SwarmToolResult | Promise<SwarmToolResult>
+                )(requestInfo, meta);
+              } finally {
+                durationMs = Date.now() - startedAt;
+              }
+            }
             const result = await finalizeSwarmToolResult(name, outcome, requestInfo);
+            dispatchPostToolCall(pre.dispatcher, name, {}, outcome, requestInfo, durationMs);
             span.setAttributes(toolResultAttributes(result));
             return result;
           },
@@ -831,14 +936,33 @@ export const createToolRegistrar = (server: McpServer) => {
         // trace tree. Cardinality is bounded — tool names are a fixed enum.
         `mcp.tool ${name}`,
         async (span) => {
-          const outcome = await (
-            cb as (
-              args: InferInput<InputArgs>,
-              requestInfo: RequestInfo,
-              meta: Meta,
-            ) => SwarmToolResult | Promise<SwarmToolResult>
-          )(args, requestInfo, meta);
+          const pre = await applyPreToolCall(name, args, requestInfo, config.inputSchema);
+          const effectiveArgs = pre.args as InferInput<InputArgs>;
+          let durationMs = 0;
+          let outcome = pre.blocked;
+          if (!outcome) {
+            const startedAt = Date.now();
+            try {
+              outcome = await (
+                cb as (
+                  args: InferInput<InputArgs>,
+                  requestInfo: RequestInfo,
+                  meta: Meta,
+                ) => SwarmToolResult | Promise<SwarmToolResult>
+              )(effectiveArgs, requestInfo, meta);
+            } finally {
+              durationMs = Date.now() - startedAt;
+            }
+          }
           const result = await finalizeSwarmToolResult(name, outcome, requestInfo);
+          dispatchPostToolCall(
+            pre.dispatcher,
+            name,
+            effectiveArgs,
+            outcome,
+            requestInfo,
+            durationMs,
+          );
           span.setAttributes(toolResultAttributes(result));
           return result;
         },