@synergenius/flow-weaver-pack-weaver 0.9.152 → 0.9.154

package/src/node-types/plan-task.ts

@@ -1,61 +1,135 @@
-import type { WeaverContext } from '../bot/types.js';
-import { callAIWithTools, callCapabilityTriage, parseJsonResponse, normalizePlan } from '../bot/ai-client.js';
-import type { AiTool } from '../bot/ai-client.js';
+import type { WeaverContext, StepLogEntry } from '../bot/types.js';
+import { callPlatformWithMessages, callCapabilityTriage } from '../bot/ai-client.js';
+import type { AiTool, AiCallResult, ChatMessage } from '../bot/ai-client.js';
 import { auditEmit } from '../bot/audit-logger.js';
-import { PLAN_OPERATIONS } from '../bot/operations.js';
+import { executeStep } from '../bot/step-executor.js';
 import { getCapabilitiesByNames, BUILT_IN_CAPABILITIES } from '../bot/capability-registry.js';
 
 // ---------------------------------------------------------------------------
-// Plan tool definition — passed via native tool_use so the AI returns
-// structured JSON arguments instead of prose. Works across Anthropic and OpenAI.
+// Tool definitions — built dynamically from capability-granted operations
 // ---------------------------------------------------------------------------
 
-/** Build the create_plan tool definition with dynamic operation list. */
-function buildPlanTool(operations: string[]): AiTool {
-  const ops = operations.length > 0 ? operations : PLAN_OPERATIONS as unknown as string[];
-  return {
-    name: 'create_plan',
-    description: 'Create a structured execution plan for this task. Call this tool with the plan steps and summary.',
+/** All known tool schemas, keyed by operation name. */
+const TOOL_SCHEMAS: Record<string, AiTool> = {
+  read_file: {
+    name: 'read_file',
+    description: 'Read a file and return its content',
+    parameters: { type: 'object', properties: { file: { type: 'string' } }, required: ['file'] },
+  },
+  write_file: {
+    name: 'write_file',
+    description: 'Write a file (full content)',
+    parameters: { type: 'object', properties: { file: { type: 'string' }, content: { type: 'string' } }, required: ['file', 'content'] },
+  },
+  patch_file: {
+    name: 'patch_file',
+    description: 'Find and replace in a file',
     parameters: {
       type: 'object',
       properties: {
-        summary: { type: 'string', description: 'One-line summary of what the plan does' },
-        steps: {
-          type: 'array',
-          description: 'Ordered list of operations to execute',
-          items: {
-            type: 'object',
-            properties: {
-              operation: {
-                type: 'string',
-                description: `Tool to invoke: ${ops.join(', ')}`,
-              },
-              description: { type: 'string', description: 'What this step does' },
-              args: {
-                type: 'object',
-                description: 'Arguments for the operation (e.g. {file, content} for write_file, {file, find, replace} for patch_file)',
-              },
-            },
-            required: ['operation', 'description', 'args'],
-          },
-        },
+        file: { type: 'string' },
+        patches: { type: 'array', items: { type: 'object', properties: { find: { type: 'string' }, replace: { type: 'string' } } } },
       },
-      required: ['summary', 'steps'],
+      required: ['file', 'patches'],
     },
-  };
+  },
+  run_shell: {
+    name: 'run_shell',
+    description: 'Run a shell command',
+    parameters: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'] },
+  },
+  list_files: {
+    name: 'list_files',
+    description: 'List files in a directory',
+    parameters: { type: 'object', properties: { directory: { type: 'string' }, pattern: { type: 'string' } } },
+  },
+  task_create: {
+    name: 'task_create',
+    description: 'Create a swarm subtask',
+    parameters: {
+      type: 'object',
+      properties: {
+        title: { type: 'string' },
+        description: { type: 'string' },
+        assignedProfile: { type: 'string' },
+        parentId: { type: 'string' },
+        dependsOn: { type: 'array', items: { type: 'string' } },
+        complexity: { type: 'string' },
+      },
+      required: ['title'],
+    },
+  },
+  done: {
+    name: 'done',
+    description: 'Signal task completion. Call this when you have finished the task.',
+    parameters: { type: 'object', properties: { summary: { type: 'string' } }, required: ['summary'] },
+  },
+  remember: {
+    name: 'remember',
+    description: 'Save a project convention for future sessions',
+    parameters: { type: 'object', properties: { key: { type: 'string' }, value: { type: 'string' } }, required: ['key', 'value'] },
+  },
+  recall: {
+    name: 'recall',
+    description: 'Recall saved project conventions',
+    parameters: { type: 'object', properties: {} },
+  },
+  validate: {
+    name: 'validate',
+    description: 'Validate a Flow Weaver workflow file',
+    parameters: { type: 'object', properties: { file: { type: 'string' } }, required: ['file'] },
+  },
+  respond: {
+    name: 'respond',
+    description: 'Send a text response to the user',
+    parameters: { type: 'object', properties: { response: { type: 'string' } }, required: ['response'] },
+  },
+};
+
+/** Build tool definitions from capability-granted operation names. */
+function buildToolDefinitions(grantedTools: string[]): AiTool[] {
+  const tools: AiTool[] = [];
+  const seen = new Set<string>();
+
+  for (const name of grantedTools) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const schema = TOOL_SCHEMAS[name];
+    if (schema) tools.push(schema);
+  }
+
+  // Always include 'done' so the AI can signal completion
+  if (!seen.has('done')) {
+    tools.push(TOOL_SCHEMAS.done);
+  }
+
+  return tools;
 }
 
+// ---------------------------------------------------------------------------
+// Safety limits
+// ---------------------------------------------------------------------------
+
+const MAX_TOOL_CALLS = 30;
+const AGENT_TIMEOUT_MS = 180_000; // 3 minutes
+
+// ---------------------------------------------------------------------------
+// Agent Loop — replaces Plan Task + Execute & Validate
+// ---------------------------------------------------------------------------
+
 /**
- * Sends task + context to the AI provider and gets back a structured
- * execution plan. The core AI planning node.
+ * Agent loop: sends task + tools to the AI, executes tool calls iteratively
+ * until the AI signals completion or a safety limit is reached.
+ *
+ * Replaces the old Plan Task → Execute & Validate two-phase workflow.
  *
  * @flowWeaver nodeType
- * @label Plan Task
- * @icon task
+ * @label Agent Loop
+ * @icon psychology
  * @color blue
  * @input ctx [order:0] - Weaver context (JSON)
  * @input [modelOverride] [order:1] - Model ID override from profile behavior
- * @output ctx [order:0] - Weaver context with planJson (JSON)
+ * @output ctx [order:0] - Weaver context with results (JSON)
  * @output onSuccess [order:-2] - On Success
  * @output onFailure [order:-1] [hidden] - On Failure
  */
@@ -72,15 +146,24 @@ export async function weaverPlanTask(
 
   if (!execute) {
     context.planJson = '{"steps":[],"summary":"dry run"}';
+    context.resultJson = JSON.stringify({ success: true, toolCallCount: 0 });
+    context.filesModified = '[]';
+    context.stepLogJson = '[]';
+    context.allValid = true;
     return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
   }
 
   const pInfo = modelOverride
     ? { ...env.providerInfo, model: modelOverride }
     : env.providerInfo;
+  const { projectDir } = env;
 
   if (!context.taskJson) {
-    context.planJson = JSON.stringify({ steps: [], summary: 'Planning failed: missing taskJson' });
+    context.planJson = JSON.stringify({ steps: [], summary: 'Agent loop failed: missing taskJson' });
+    context.resultJson = JSON.stringify({ success: false, error: 'missing taskJson' });
+    context.filesModified = '[]';
+    context.stepLogJson = '[]';
+    context.allValid = false;
     return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
   }
   const task = JSON.parse(context.taskJson);
@@ -91,80 +174,222 @@ export async function weaverPlanTask(
   const availableCaps = getCapabilitiesByNames(availableCapNames);
 
   // Capability triage: cheap Haiku call selects which capabilities this task needs
-  let selectedCaps = availableCaps; // fallback: all available
+  let selectedCaps = availableCaps;
   const triageResult = await callCapabilityTriage(pInfo, task.instruction, availableCaps);
   if (triageResult) {
     selectedCaps = getCapabilitiesByNames(triageResult);
   }
-  // If triage failed, selectedCaps = all available (no degradation)
 
+  // Build system prompt from capabilities
   let systemPrompt: string;
   try {
     const mod = await import('../bot/system-prompt.js');
     const basePrompt = mod.buildPromptFromCapabilities(selectedCaps);
-    // Only include the context bundle if the 'context' capability was selected.
-    // This prevents sending 10k+ tokens of FW authoring docs for simple file creation tasks.
     const selectedCapNames = new Set(selectedCaps.map(c => c.name));
     const contextBundle = selectedCapNames.has('context') ? context.contextBundle : undefined;
     const botPrompt = mod.buildBotSystemPrompt(contextBundle, undefined, context.env?.projectDir);
     systemPrompt = basePrompt + '\n\n' + botPrompt;
   } catch (err) {
-    if (process.env.WEAVER_VERBOSE) console.error('[plan-task] system prompt build failed:', err);
-    systemPrompt = 'You are Weaver, an AI workflow bot. Return ONLY valid JSON with a plan.';
+    if (process.env.WEAVER_VERBOSE) console.error('[agent-loop] system prompt build failed:', err);
+    systemPrompt = 'You are Weaver, an AI workflow bot. Use the provided tools to complete tasks.';
   }
 
-  const userPrompt = `Task: ${task.instruction}\nMode: ${task.mode ?? 'create'}\n${task.id ? `Your Task ID is ${task.id} — use this as parentId in every task_create call.` : ''}\n${task.targets ? 'Targets: ' + task.targets.join(', ') : ''}
+  // Build tool definitions from capability-granted operations
+  let tools: AiTool[];
+  try {
+    const mod2 = await import('../bot/system-prompt.js');
+    const grantedTools = mod2.collectToolsFromCapabilities(selectedCaps);
+    tools = buildToolDefinitions(grantedTools);
+  } catch {
+    tools = buildToolDefinitions(['read_file', 'write_file', 'patch_file', 'run_shell', 'list_files', 'task_create']);
+  }
+
+  // Build initial user prompt
+  let userPrompt = `Task: ${task.instruction}\nMode: ${task.mode ?? 'create'}\n${task.id ? `Your Task ID is ${task.id}. Use parentId: "@self" in task_create to create subtasks under this task.` : ''}\n${task.targets ? 'Targets: ' + task.targets.join(', ') : ''}
 
-Plan this task by calling the create_plan tool with concrete steps.
+Execute this task step by step using the available tools.
+When you are done, call the "done" tool with a summary of what you accomplished.
 Rules:
-1. Every step MUST have complete, concrete args — no empty patches, no placeholders.
-2. For file creation tasks, use write_file with full file content in args.
-3. If you need to discover file contents first, plan ONLY discovery steps (read_file, list_files).
-4. Do NOT plan patch_file unless you know the exact find/replace strings.`;
+1. Read files before modifying them (use read_file to get exact content for patches).
+2. Use patch_file for modifications, write_file only for new files.
+3. Verify your work by running tests or tsc when appropriate.`;
+
+  // Append retry context when this is a retry attempt (attempt > 0)
+  const attempt = task.attempt ?? 0;
+  if (attempt > 0) {
+    const retryParts: string[] = ['\n\n--- RETRY CONTEXT (attempt ' + (attempt + 1) + ') ---'];
+    if (task.lastError) {
+      retryParts.push('Previous attempt failed with error: ' + task.lastError);
+    }
+    const summaries: Array<{ outcome?: string; filesModified?: string[]; summary?: string }> = task.runSummaries ?? [];
+    const lastSummary = summaries.length > 0 ? summaries[summaries.length - 1] : undefined;
+    if (lastSummary) {
+      if (lastSummary.outcome) retryParts.push('Last outcome: ' + lastSummary.outcome);
+      if (lastSummary.summary) retryParts.push('Last summary: ' + lastSummary.summary);
+      if (lastSummary.filesModified && lastSummary.filesModified.length > 0) {
+        retryParts.push('Files already created/modified: ' + lastSummary.filesModified.join(', '));
+      }
+    }
+    retryParts.push('Do NOT recreate files that already exist. Read them first and continue from where the previous attempt left off.');
+    retryParts.push('---');
+    userPrompt += retryParts.join('\n');
+  }
+
+  // Seed symbolic ID map for task references
+  const symbolicIdMap: Record<string, string> = {};
+  if (task.id) symbolicIdMap['@self'] = task.id;
+  if (task.parentId) symbolicIdMap['@parent'] = task.parentId;
+
+  // State tracking
+  const filesModified: string[] = [];
+  const stepLog: StepLogEntry[] = [];
+  let toolCallCount = 0;
+  const deadline = Date.now() + AGENT_TIMEOUT_MS;
+
+  // Messages array for multi-turn conversation
+  const messages: ChatMessage[] = [
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: userPrompt },
+  ];
+
+  auditEmit('run-start', { task: task.instruction, mode: 'agent-loop' });
 
   try {
-    // Build plan tool with operations scoped to selected capabilities
-    const mod2 = await import('../bot/system-prompt.js');
-    const grantedTools = mod2.collectToolsFromCapabilities(selectedCaps);
-    // Always include respond in the available operations
-    const planOps = grantedTools.length > 0 ? [...grantedTools, 'respond'] : PLAN_OPERATIONS as unknown as string[];
-    const planTool = buildPlanTool(planOps);
-
-    // Use native tool_use when available (Anthropic, OpenAI).
-    // The AI calls create_plan with structured args instead of returning prose.
-    const result = await callAIWithTools(pInfo, systemPrompt, userPrompt, [planTool], 8192);
-
-    let plan: { steps: Array<{ id: string; operation: string; description: string; args: Record<string, unknown> }>; summary: string };
-
-    // Check if AI used the create_plan tool (structured response)
-    const planCall = result.toolCalls.find(tc => tc.name === 'create_plan');
-    if (planCall) {
-      plan = normalizePlan(planCall.arguments);
-    } else {
-      // Fallback: parse JSON from text content (CLI providers, or AI chose not to use tool)
-      const text = result.content;
-      try {
-        const raw = parseJsonResponse(text);
-        plan = normalizePlan(raw);
-      } catch {
-        // LLM returned plain text — wrap as a text-response plan.
-        const trimmed = text.trim();
-        const firstLine = trimmed.split('\n')[0].slice(0, 120);
-        plan = {
-          steps: [{ id: 'step-1', operation: 'respond', description: firstLine, args: { response: trimmed } }],
-          summary: firstLine,
-        };
+    // Agent loop
+    let done = false;
+    while (!done && toolCallCount < MAX_TOOL_CALLS && Date.now() < deadline) {
+      const result: AiCallResult = await callPlatformWithMessages(messages, tools, pInfo.model, pInfo.maxTokens ?? 8192);
+
+      // If AI returns text with no tool calls, we're done
+      if (!result.toolCalls || result.toolCalls.length === 0) {
+        if (result.content) {
+          console.log(`\x1b[36m→ Agent: ${result.content.slice(0, 200)}\x1b[0m`);
+        }
+        done = true;
+        break;
+      }
+
+      // Process each tool call
+      for (const tc of result.toolCalls) {
+        if (toolCallCount >= MAX_TOOL_CALLS || Date.now() >= deadline) {
+          done = true;
+          break;
+        }
+
+        toolCallCount++;
+        const toolName = tc.name;
+        const toolArgs = tc.arguments;
+
+        // Check for done signal
+        if (toolName === 'done' || toolName === 'complete') {
+          console.log(`\x1b[36m→ Agent done: ${(toolArgs as Record<string, string>).summary ?? 'completed'}\x1b[0m`);
+
+          // Execute through step-executor for consistent handling
+          try {
+            const stepResult = await executeStep(
+              { operation: toolName, args: toolArgs },
+              projectDir,
+              symbolicIdMap,
+            );
+            stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'ok', detail: stepResult.output ?? 'done' });
+          } catch {
+            stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'ok', detail: 'done' });
+          }
+
+          // Add assistant message with tool use and tool result to messages
+          messages.push({
+            role: 'assistant',
+            content: result.content || undefined,
+            tool_use: { id: tc.id, name: toolName, input: toolArgs },
+          });
+          messages.push({
+            role: 'user',
+            tool_use_id: tc.id,
+            content: 'Task completed.',
+          });
+
+          done = true;
+          break;
+        }
+
+        // Execute the tool via step-executor
+        let toolOutput: string;
+        try {
+          const stepResult = await executeStep(
+            { operation: toolName, args: toolArgs },
+            projectDir,
+            symbolicIdMap,
+          );
+
+          // Track files modified — only from write/patch operations, not reads/listings
+          const isWriteOp = toolName === 'write_file' || toolName === 'patch_file' || toolName === 'create_workflow' || toolName === 'modify_source' || toolName === 'implement_node';
+          if (isWriteOp && stepResult.file) filesModified.push(stepResult.file);
+
+          // Build output for AI
+          if (stepResult.blocked) {
+            toolOutput = `BLOCKED: ${stepResult.blockReason}`;
+            stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'blocked', detail: stepResult.blockReason });
+          } else {
+            toolOutput = stepResult.output ?? 'OK';
+            stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'ok', detail: toolName });
+          }
+
+          console.log(`\x1b[32m  + ${toolCallCount}: ${toolName}\x1b[0m`);
+        } catch (err: unknown) {
+          const msg = err instanceof Error ? err.message : String(err);
+          toolOutput = `ERROR: ${msg}`;
+          stepLog.push({ step: `${toolCallCount}:${toolName}`, status: 'error', detail: msg });
+          console.error(`\x1b[31m  x ${toolCallCount}: ${toolName}: ${msg}\x1b[0m`);
+        }
+
+        // Append assistant tool_use + tool result to messages for next iteration
+        messages.push({
+          role: 'assistant',
+          content: result.content || undefined,
+          tool_use: { id: tc.id, name: toolName, input: toolArgs },
+        });
+        messages.push({
+          role: 'user',
+          tool_use_id: tc.id,
+          content: toolOutput,
+        });
       }
     }
-    console.log(`\x1b[36m→ Plan: ${plan.summary ?? 'generated'}\x1b[0m`);
-    auditEmit('plan-created', { summary: plan.summary, stepCount: plan.steps?.length ?? 0 });
 
-    context.planJson = JSON.stringify(plan);
+    // Deduplicate files
+    const uniqueFiles = [...new Set(filesModified)];
+
+    // Store results in context (compatible with exec-validate-retry output format)
+    context.resultJson = JSON.stringify({
+      success: true,
+      toolCallCount,
+      filesModified: uniqueFiles,
+      stepsCompleted: toolCallCount,
+      stepsTotal: toolCallCount,
+    });
+    context.planJson = JSON.stringify({ steps: [], summary: `Agent loop: ${toolCallCount} tool calls` });
+    context.filesModified = JSON.stringify(uniqueFiles);
+    context.stepLogJson = JSON.stringify(stepLog);
+    context.allValid = true;
+
+    auditEmit('run-complete', {
+      success: true,
+      toolCalls: toolCallCount,
+      filesModified: uniqueFiles.length,
+    });
+
+    console.log(`\x1b[36m→ Agent loop: ${toolCallCount} tool calls, ${uniqueFiles.length} files modified\x1b[0m`);
     return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(`\x1b[31m→ Planning failed: ${msg}\x1b[0m`);
-    context.planJson = JSON.stringify({ steps: [], summary: `Planning failed: ${msg}` });
+    console.error(`\x1b[31m→ Agent loop failed: ${msg}\x1b[0m`);
+
+    context.resultJson = JSON.stringify({ success: false, error: msg });
+    context.planJson = JSON.stringify({ steps: [], summary: `Agent loop failed: ${msg}` });
+    context.filesModified = JSON.stringify([...new Set(filesModified)]);
+    context.stepLogJson = JSON.stringify(stepLog);
+    context.allValid = false;
+
     return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
   }
 }

package/src/ui/bot-panel.tsx

@@ -286,7 +286,7 @@ function BotPanel() {
         React.createElement(Flex, { variant: 'row-center-start-nowrap-4' },
           React.createElement(Typography, {
             variant: 'caption-thick', color: 'color-text-high',
-          }, `${inst.profileId} #${inst.index}`),
+          }, inst.profileId ? `${inst.instanceId} (${inst.profileId})` : inst.instanceId),
           React.createElement(StatusIcon, {
             status: statusToIconStatus(inst.status),
             size: 'sm',

package/src/ui/chat-task-result.tsx

@@ -18,16 +18,18 @@ const { Flex, Typography, StatusIcon, Button } = require('@fw/plugin-ui-kit');
 interface TaskData {
   id: string;
   title: string;
-  status: 'pending' | 'in-progress' | 'blocked' | 'done' | 'failed' | 'cancelled';
+  status: 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
   isParent: boolean;
   currentBotId?: string;
   assignedProfile?: string;
+  attempt?: number;
+  maxAttempts?: number;
 }
 
 interface SubtaskData {
   id: string;
   title: string;
-  status: 'pending' | 'in-progress' | 'blocked' | 'done' | 'failed' | 'cancelled';
+  status: 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
 }
 
 interface ChatTaskResultProps {
@@ -59,6 +61,7 @@ type StatusKind = 'running' | 'completed' | 'failed' | 'pending';
 
 function statusToIcon(status: TaskData['status']): StatusKind {
   switch (status) {
+    case 'open':
     case 'pending':
     case 'blocked':
       return 'pending';
@@ -66,7 +69,6 @@ function statusToIcon(status: TaskData['status']): StatusKind {
       return 'running';
     case 'done':
       return 'completed';
-    case 'failed':
     case 'cancelled':
       return 'failed';
     default:
@@ -76,18 +78,18 @@ function statusToIcon(status: TaskData['status']): StatusKind {
 
 function statusLabel(status: TaskData['status']): string {
   switch (status) {
-    case 'pending': return 'Pending';
-    case 'in-progress': return 'In Progress';
+    case 'open': return 'Open';
+    case 'pending': return 'Queued';
+    case 'in-progress': return 'Running';
     case 'blocked': return 'Blocked';
     case 'done': return 'Done';
-    case 'failed': return 'Failed';
     case 'cancelled': return 'Cancelled';
     default: return status;
   }
 }
 
 function isTerminal(status: TaskData['status']): boolean {
-  return status === 'done' || status === 'failed' || status === 'cancelled';
+  return status === 'done' || status === 'cancelled';
 }
 
 // ---------------------------------------------------------------------------
@@ -204,7 +206,7 @@ function ChatTaskResult(props: ChatTaskResultProps | null) {
         React.createElement(Typography, {
           variant: 'smallCaption-regular',
           color: task.status === 'done' ? 'color-text-positive' :
-                 task.status === 'failed' ? 'color-text-negative' :
+                 task.status === 'cancelled' ? 'color-text-negative' :
                  task.status === 'in-progress' ? 'color-text-info' :
                  'color-text-medium',
         }, statusLabel(task.status)),

package/src/ui/swarm-dashboard.tsx

@@ -77,7 +77,7 @@ interface SwarmStatus {
   packVersion?: string;
 }
 
-type TaskStatus = 'pending' | 'in-progress' | 'blocked' | 'done' | 'failed' | 'cancelled';
+type TaskStatus = 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
 
 interface PoolTask {
   id: string;
@@ -357,7 +357,7 @@ function SwarmDashboard() {
     React.createElement(Tabs, {
       tabs: [
         { id: 'tasks', title: `Tasks (${tasks.length})` },
-        { id: 'bots', title: hasSwarmInstances ? `Instances (${swarmInstanceEntries.length})` : `Bots (${registeredBots.length})` },
+        { id: 'bots', title: hasSwarmInstances ? `Workers (${swarmInstanceEntries.length})` : `Bots (${registeredBots.length})` },
         { id: 'profiles', title: `Profiles (${profiles.length})` },
         { id: 'config', title: 'Config' },
       ],
@@ -475,7 +475,7 @@ function SwarmDashboard() {
             React.createElement(Typography, {
               variant: 'smallCaption-regular', color: 'color-text-subtle',
               style: { width: '120px', flexShrink: 0 },
-            }, 'Instance'),
+            }, 'Worker'),
             React.createElement(Typography, {
               variant: 'smallCaption-regular', color: 'color-text-subtle',
               style: { width: '110px', flexShrink: 0 },
@@ -511,7 +511,7 @@ function SwarmDashboard() {
               key: inst.instanceId,
               bot: {
                 botId: inst.instanceId,
-                botName: `${inst.profileId} #${inst.index}`,
+                botName: inst.profileId ? `${inst.instanceId} (${inst.profileId})` : inst.instanceId,
                 status: inst.status,
                 currentTaskId: inst.currentTaskId,
                 currentRunId: inst.currentRunId,