@desplega.ai/agent-swarm 1.51.2 → 1.52.1

package/src/commands/runner.ts

@@ -1,5 +1,6 @@
 import { existsSync, statSync } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { ensure, initialize } from "@desplega.ai/business-use";
 import type { TemplateResponse } from "../../templates/schema.ts";
 import { type BasePromptArgs, getBasePrompt } from "../prompts/base-prompt.ts";
 import {
@@ -92,6 +93,10 @@ async function ensureRepoForTask(
       } else {
         await Bun.$`git clone --branch ${defaultBranch} --single-branch ${url} ${clonePath}`.quiet();
       }
+      // Validate the clone actually created the directory
+      if (!existsSync(clonePath)) {
+        throw new Error(`Clone command succeeded but directory ${clonePath} does not exist`);
+      }
       console.log(`[${role}] Cloned ${name}`);
     } else {
       console.log(`[${role}] Repo ${name} already cloned at ${clonePath}`);
@@ -114,7 +119,9 @@ async function ensureRepoForTask(
     const errorMsg = (err as Error).message;
     console.warn(`[${role}] Error setting up repo ${name}: ${errorMsg}`);
     const warning = `Failed to clone/setup repo "${name}" at ${clonePath}: ${errorMsg}. The repo may not be available. You may need to clone it manually.`;
-    return { clonePath, claudeMd: null, warning };
+    // Only return clonePath if the directory actually exists (clone may have failed)
+    const cloneExists = existsSync(clonePath);
+    return { clonePath: cloneExists ? clonePath : "", claudeMd: null, warning };
   }
 }
 
@@ -209,10 +216,94 @@ async function fetchResolvedEnv(
   return env;
 }
 
+/** Tools that produce noise — skip auto-progress for these */
+const SKIP_PROGRESS_TOOLS = new Set(["ToolSearch", "TodoRead", "TodoWrite"]);
+
+/** Pretty labels for agent-swarm MCP tools. null = skip (meta/noise). */
+const SWARM_TOOL_LABELS: Record<string, string | null> = {
+  "store-progress": null,
+  "get-task-details": "📋 Reviewing task details",
+  "get-tasks": "📋 Checking task list",
+  "poll-task": "📡 Polling for tasks",
+  "send-task": "📤 Delegating task",
+  "task-action": "⚡ Performing task action",
+  "join-swarm": "🔗 Joining swarm",
+  "my-agent-info": "🪪 Checking agent info",
+  "get-swarm": "👥 Checking swarm status",
+  "post-message": "💬 Sending message",
+  "read-messages": "💬 Reading messages",
+  "request-human-input": "🙋 Requesting human input",
+  "cancel-task": "🚫 Cancelling task",
+  "db-query": "🗃️ Querying database",
+  "inject-learning": "🧠 Storing learning",
+  "memory-search": "🧠 Searching memory",
+  "memory-get": "🧠 Retrieving memory",
+  "update-profile": "🪪 Updating profile",
+  // Slack
+  "slack-post": "💬 Posting to Slack",
+  "slack-reply": "💬 Replying in Slack",
+  "slack-read": "💬 Reading Slack",
+  "slack-list-channels": "💬 Listing Slack channels",
+  "slack-download-file": "📥 Downloading from Slack",
+  "slack-upload-file": "📤 Uploading to Slack",
+  // Tracker
+  "tracker-status": "📊 Checking tracker status",
+  "tracker-sync-status": "📊 Syncing tracker status",
+  "tracker-link-task": "🔗 Linking task to tracker",
+  "tracker-link-epic": "🔗 Linking epic to tracker",
+  "tracker-unlink": "🔗 Unlinking from tracker",
+  "tracker-map-agent": "🔗 Mapping agent to tracker",
+  // Epics
+  "create-epic": "📦 Creating epic",
+  "get-epic-details": "📦 Reviewing epic",
+  "list-epics": "📦 Listing epics",
+  "update-epic": "📦 Updating epic",
+  // Workflows
+  "trigger-workflow": "⚙️ Triggering workflow",
+  "get-workflow": "⚙️ Checking workflow",
+  "list-workflows": "⚙️ Listing workflows",
+  "create-workflow": "⚙️ Creating workflow",
+  // Skills
+  "skill-search": "🔎 Searching skills",
+  "skill-install": "📦 Installing skill",
+  "skill-install-remote": "📦 Installing remote skill",
+  "skill-get": "📦 Getting skill details",
+  "skill-list": "📦 Listing skills",
+  // Config
+  "get-config": "⚙️ Reading config",
+  "set-config": "⚙️ Setting config",
+  "list-config": "⚙️ Listing config",
+  // Schedules
+  "create-schedule": "📅 Creating schedule",
+  "list-schedules": "📅 Listing schedules",
+  "run-schedule-now": "📅 Running schedule",
+  // Context
+  "context-diff": "📜 Viewing context diff",
+  "context-history": "📜 Viewing context history",
+  // Channels
+  "create-channel": "📢 Creating channel",
+  "list-channels": "📢 Listing channels",
+  "delete-channel": "📢 Deleting channel",
+  // Services
+  "register-service": "🔌 Registering service",
+  "list-services": "🔌 Listing services",
+  "unregister-service": "🔌 Unregistering service",
+  "update-service-status": "🔌 Updating service status",
+};
+
+/** Convert kebab-case to sentence case: "get-task-details" → "Get task details" */
+export function humanizeToolName(name: string): string {
+  if (!name) return name;
+  return name.charAt(0).toUpperCase() + name.slice(1).replaceAll("-", " ");
+}
+
 /**
  * Convert a tool call into a human-readable progress description.
+ * Returns null for noisy/meta tools that should be skipped.
  */
-function toolCallToProgress(toolName: string, args: unknown): string {
+export function toolCallToProgress(toolName: string, args: unknown): string | null {
+  if (SKIP_PROGRESS_TOOLS.has(toolName)) return null;
+
   const a = args as Record<string, unknown>;
   const shortPath = (p: unknown) => {
     if (typeof p !== "string") return "";
@@ -223,30 +314,43 @@ function toolCallToProgress(toolName: string, args: unknown): string {
 
   switch (toolName) {
     case "Read":
-      return `Reading ${shortPath(a.file_path)}`;
+      return `📖 Reading ${shortPath(a.file_path)}`;
     case "Edit":
     case "MultiEdit":
-      return `Editing ${shortPath(a.file_path)}`;
+      return `✏️ Editing ${shortPath(a.file_path)}`;
     case "Write":
-      return `Writing ${shortPath(a.file_path)}`;
+      return `📝 Writing ${shortPath(a.file_path)}`;
     case "Bash":
-      return a.description ? `${a.description}` : "Running shell command";
+      return a.description ? `⚡ ${a.description}` : "⚡ Running shell command";
     case "Grep":
-      return `Searching for "${a.pattern}"`;
+      return `🔍 Searching for "${a.pattern}"`;
     case "Glob":
-      return `Finding files matching ${a.pattern}`;
+      return `📁 Finding files matching ${a.pattern}`;
     case "Agent":
     case "Task":
-      return a.description ? `${a.description}` : "Delegating sub-task";
+      return a.description ? `🤖 ${a.description}` : "🤖 Delegating sub-task";
     case "Skill":
-      return `Running /${a.skill}`;
+      return `⚙️ Running /${a.skill}`;
     default: {
-      // MCP tools: mcp__server__tool → "server:tool"
+      // MCP tools: mcp__server__tool
       if (toolName.startsWith("mcp__")) {
         const parts = toolName.split("__");
-        return parts.length >= 3 ? `Using ${parts[1]}:${parts[2]}` : `Using ${toolName}`;
+        if (parts.length >= 3) {
+          const server = parts[1];
+          const tool = parts.slice(2).join("__");
+          // Agent-swarm tools get pretty labels
+          if (server === "agent-swarm") {
+            const label = SWARM_TOOL_LABELS[tool];
+            if (label === null) return null; // skip
+            if (label) return label;
+            return `🔌 ${humanizeToolName(tool)}`;
+          }
+          // Other MCP servers: "🔌 server: Humanized tool"
+          return `🔌 ${server}: ${humanizeToolName(tool)}`;
+        }
+        return `🔌 ${toolName}`;
       }
-      return `Using ${toolName}`;
+      return `🔧 ${toolName}`;
     }
   }
 }
@@ -1363,9 +1467,13 @@ async function spawnProviderProcess(
         // Auto-progress: report tool activity as task progress (throttled)
         const now = Date.now();
         if (effectiveTaskId && opts.apiUrl && now - lastProgressTime >= PROGRESS_THROTTLE_MS) {
-          lastProgressTime = now;
           const progress = toolCallToProgress(event.toolName, event.args);
-          updateProgressViaAPI(opts.apiUrl, opts.apiKey, effectiveTaskId, progress).catch(() => {});
+          if (progress) {
+            lastProgressTime = now;
+            updateProgressViaAPI(opts.apiUrl, opts.apiKey, effectiveTaskId, progress).catch(
+              () => {},
+            );
+          }
         }
         break;
       }
@@ -1573,6 +1681,22 @@ async function checkCompletedProcesses(
       }
       await ensureTaskFinished(apiConfig, role, taskId, result.exitCode, failureReason);
 
+      ensure({
+        id: "worker_process_finished",
+        flow: "task",
+        runId: taskId,
+        depIds: ["worker_process_spawned"],
+        data: {
+          taskId,
+          agentId: apiConfig.agentId,
+          role,
+          exitCode: result.exitCode,
+          success: result.exitCode === 0,
+          failureReason,
+        },
+        validator: (data) => data.exitCode === 0,
+      });
+
       // Commit channel activity cursors after successful processing
       // If the task failed, cursors stay uncommitted so messages are re-seen on next poll
       if (cursorUpdates && cursorUpdates.length > 0 && result.exitCode === 0) {
@@ -1659,6 +1783,9 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   const { defaultPrompt, metadataType } = config;
   let role = config.role;
 
+  // Initialize Business-Use SDK for worker-side instrumentation
+  initialize();
+
   // Create provider adapter based on HARNESS_PROVIDER env var (default: claude)
   const adapter = createProviderAdapter(process.env.HARNESS_PROVIDER || "claude");
 
@@ -1692,6 +1819,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   let agentClaudeMd: string | undefined;
   let agentProfileName: string | undefined;
   let agentDescription: string | undefined;
+  let agentSkillsSummary: { name: string; description: string }[] | undefined;
 
   // Per-task repo context — set when processing a task with githubRepo
   let currentRepoContext: BasePromptArgs["repoContext"] | undefined;
@@ -1710,6 +1838,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       toolsMd: agentToolsMd,
       claudeMd: agentClaudeMd,
       repoContext: currentRepoContext,
+      skillsSummary: agentSkillsSummary,
     });
   };
 
@@ -1937,6 +2066,34 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           }
         }
 
+        // Fetch installed skills for system prompt
+        try {
+          const skillsResp = await fetch(`${apiUrl}/api/agents/${agentId}/skills`, {
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              "X-Agent-ID": agentId,
+            },
+          });
+          if (skillsResp.ok) {
+            const skillsData = (await skillsResp.json()) as {
+              skills: {
+                name: string;
+                description: string;
+                isActive: boolean;
+                isEnabled: boolean;
+              }[];
+            };
+            agentSkillsSummary = skillsData.skills
+              .filter((s) => s.isActive && s.isEnabled)
+              .map((s) => ({ name: s.name, description: s.description }));
+            if (agentSkillsSummary.length > 0) {
+              console.log(`[${role}] Loaded ${agentSkillsSummary.length} skills for system prompt`);
+            }
+          }
+        } catch {
+          // Non-fatal — skills are optional
+        }
+
         // Rebuild system prompt with identity
         basePrompt = await buildSystemPrompt();
         resolvedSystemPrompt = additionalSystemPrompt
@@ -2005,6 +2162,37 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       }
     }
 
+    // ========== Sync skills to filesystem ==========
+    try {
+      console.log(`[${role}] Syncing skills to filesystem...`);
+      const syncHeaders: Record<string, string> = {
+        "Content-Type": "application/json",
+        "X-Agent-ID": agentId,
+      };
+      if (apiKey) syncHeaders.Authorization = `Bearer ${apiKey}`;
+      const syncRes = await fetch(`${swarmUrl}/api/skills/sync-filesystem`, {
+        method: "POST",
+        headers: syncHeaders,
+      });
+      if (syncRes.ok) {
+        const syncResult = (await syncRes.json()) as {
+          synced: number;
+          removed: number;
+          errors: string[];
+        };
+        console.log(
+          `[${role}] Skills synced: ${syncResult.synced} written, ${syncResult.removed} removed`,
+        );
+        if (syncResult.errors.length > 0) {
+          console.warn(`[${role}] Skill sync errors: ${syncResult.errors.join(", ")}`);
+        }
+      } else {
+        console.warn(`[${role}] Skill sync failed: HTTP ${syncRes.status}`);
+      }
+    } catch (err) {
+      console.warn(`[${role}] Skill sync failed: ${(err as Error).message}`);
+    }
+
     // ========== Resume paused tasks with PRIORITY ==========
     // Check for paused tasks from previous shutdown and resume them before normal polling
     try {
@@ -2128,26 +2316,36 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           // Per-task runner session ID so session logs are scoped to this task
           const resumeRunnerSessionId = crypto.randomUUID();
 
-          const runningTask = await spawnProviderProcess(
-            adapter,
-            {
-              prompt: resumePrompt,
-              logFile,
-              systemPrompt: resolvedSystemPrompt,
-              additionalArgs: resumeAdditionalArgs,
-              role,
-              apiUrl,
-              apiKey,
-              agentId,
-              runnerSessionId: resumeRunnerSessionId,
-              iteration,
-              taskId: task.id,
-              model: (task as { model?: string }).model,
-              cwd: resumeCwd,
-            },
-            logDir,
-            isYolo,
-          );
+          let runningTask: RunningTask;
+          try {
+            runningTask = await spawnProviderProcess(
+              adapter,
+              {
+                prompt: resumePrompt,
+                logFile,
+                systemPrompt: resolvedSystemPrompt,
+                additionalArgs: resumeAdditionalArgs,
+                role,
+                apiUrl,
+                apiKey,
+                agentId,
+                runnerSessionId: resumeRunnerSessionId,
+                iteration,
+                taskId: task.id,
+                model: (task as { model?: string }).model,
+                cwd: resumeCwd,
+              },
+              logDir,
+              isYolo,
+            );
+          } catch (spawnErr) {
+            const errMsg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
+            console.error(
+              `[${role}] Failed to spawn process for resumed task ${task.id.slice(0, 8)}: ${errMsg}`,
+            );
+            await ensureTaskFinished(apiConfig, role, task.id, 1, `Spawn failed: ${errMsg}`);
+            continue;
+          }
 
           state.activeTasks.set(task.id, runningTask);
           registerActiveSession(apiConfig, {
@@ -2231,6 +2429,24 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         if (trigger) {
           console.log(`[${role}] Trigger received: ${trigger.type}`);
 
+          if (
+            trigger.taskId &&
+            (trigger.type === "task_assigned" || trigger.type === "task_offered")
+          ) {
+            ensure({
+              id: "worker_received",
+              flow: "task",
+              runId: trigger.taskId,
+              depIds: ["started"],
+              data: {
+                taskId: trigger.taskId,
+                agentId,
+                triggerType: trigger.type,
+                role,
+              },
+            });
+          }
+
           // Build prompt based on trigger
           let triggerPrompt = await buildPromptForTrigger(
             trigger,
@@ -2408,26 +2624,57 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           const taskRunnerSessionId = crypto.randomUUID();
 
           // Spawn without blocking (await to set up session, but process runs async)
-          const runningTask = await spawnProviderProcess(
-            adapter,
-            {
-              prompt: triggerPrompt,
-              logFile,
-              systemPrompt: taskSystemPrompt,
-              additionalArgs: effectiveAdditionalArgs,
-              role,
-              apiUrl,
-              apiKey,
+          let runningTask: RunningTask;
+          try {
+            runningTask = await spawnProviderProcess(
+              adapter,
+              {
+                prompt: triggerPrompt,
+                logFile,
+                systemPrompt: taskSystemPrompt,
+                additionalArgs: effectiveAdditionalArgs,
+                role,
+                apiUrl,
+                apiKey,
+                agentId,
+                runnerSessionId: taskRunnerSessionId,
+                iteration,
+                taskId: trigger.taskId,
+                model: taskModel,
+                cwd: effectiveCwd,
+              },
+              logDir,
+              isYolo,
+            );
+          } catch (spawnErr) {
+            const errMsg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
+            console.error(
+              `[${role}] Failed to spawn process for task ${trigger.taskId?.slice(0, 8) || "unknown"}: ${errMsg}`,
+            );
+            if (trigger.taskId) {
+              await ensureTaskFinished(
+                apiConfig,
+                role,
+                trigger.taskId,
+                1,
+                `Spawn failed: ${errMsg}`,
+              );
+            }
+            continue;
+          }
+
+          ensure({
+            id: "worker_process_spawned",
+            flow: "task",
+            runId: runningTask.taskId,
+            depIds: ["worker_received"],
+            data: {
+              taskId: runningTask.taskId,
               agentId,
-              runnerSessionId: taskRunnerSessionId,
-              iteration,
-              taskId: trigger.taskId,
+              role,
               model: taskModel,
-              cwd: effectiveCwd,
             },
-            logDir,
-            isYolo,
-          );
+          });
 
           // Attach trigger metadata for logging
           runningTask.triggerType = trigger.type;

package/src/http/agents.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { ensure } from "@desplega.ai/business-use";
 import { z } from "zod";
 import {
   createAgent,
@@ -179,6 +180,34 @@ export async function handleAgentRegister(
       return { agent, created: true };
     })();
 
+    if (result.created) {
+      ensure({
+        id: "registered",
+        flow: "agent",
+        runId: agentId,
+        data: {
+          agentId,
+          name: parsed.body.name,
+          isLead: parsed.body.isLead ?? false,
+        },
+      });
+    } else {
+      ensure({
+        id: "reconnected",
+        flow: "agent",
+        runId: agentId,
+        depIds: ["registered"],
+        data: {
+          agentId,
+          name: parsed.body.name,
+        },
+        validator: (_data, ctx) => {
+          // Validates that registered happened before reconnected
+          return ctx.deps.length > 0;
+        },
+      });
+    }
+
     json(res, result.agent, result.created ? 201 : 200);
     return true;
   }