@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/slash/slash-live-state.js

@@ -1,3 +1,5 @@
+import { previewSimpleWorkflowRun } from "../workflows/scripted-workflow.js";
+import { deriveChildSessionName } from "../shared/child-session-name.js";
 import { SLASH_RESULT_TYPE } from "../shared/types.js";
 const liveSnapshots = new Map;
 const finalSnapshots = new Map;
@@ -18,15 +20,19 @@ function cloneUsage() {
   return { ...EMPTY_USAGE };
 }
 function createPlaceholderResult(agent, task, status, index) {
+  const sessionName = deriveChildSessionName({ agent, task });
   return {
     agent,
     task,
+    ...sessionName ? { sessionName } : {},
+    index,
     exitCode: 0,
     messages: EMPTY_MESSAGES,
     usage: cloneUsage(),
     progress: {
-      ...index !== undefined ? { index } : {},
+      index,
       agent,
+      ...sessionName ? { sessionName } : {},
       status,
       task,
       recentTools: [],
@@ -45,19 +51,24 @@ function buildParallelInitialResult(params) {
 `) }],
     details: {
       mode: "parallel",
-      ...params.context ? { context: params.context } : {},
+      ...params.async ? { background: true } : {},
+      ...params.context === "fresh" || params.context === "fork" ? { context: params.context } : {},
       results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
-      progress: tasks.map((task, index) => ({
-        index,
-        agent: task.agent,
-        status: "running",
-        task: task.task,
-        recentTools: [],
-        recentOutput: [],
-        toolCount: 0,
-        tokens: 0,
-        durationMs: 0
-      }))
+      progress: tasks.map((task, index) => {
+        const sessionName = deriveChildSessionName({ agent: task.agent, task: task.task });
+        return {
+          index,
+          agent: task.agent,
+          ...sessionName ? { sessionName } : {},
+          status: "running",
+          task: task.task,
+          recentTools: [],
+          recentOutput: [],
+          toolCount: 0,
+          tokens: 0,
+          durationMs: 0
+        };
+      })
     }
   };
 }
@@ -99,11 +110,13 @@ ${result.task}`).join(`
     }],
     details: {
       mode: "chain",
-      ...params.context ? { context: params.context } : {},
+      ...params.async ? { background: true } : {},
+      ...params.context === "fresh" || params.context === "fork" ? { context: params.context } : {},
       results,
       progress: results.map((result, index) => ({
         index,
         agent: result.agent,
+        ...result.sessionName ? { sessionName: result.sessionName } : {},
         status: index === 0 ? "running" : "pending",
         task: result.task,
         recentTools: [],
@@ -119,16 +132,21 @@ ${result.task}`).join(`
   };
 }
 function buildSingleInitialResult(params) {
-  const agent = params.agent ?? "subagent";
-  const task = params.task ?? "";
+  const preview = previewSimpleWorkflowRun(params.workflowScript) ?? {};
+  const agent = params.agent ?? preview.agent ?? "subagent";
+  const task = params.task ?? preview.task ?? "";
+  const sessionName = deriveChildSessionName({ agent, task });
   return {
     content: [{ type: "text", text: task }],
     details: {
       mode: "single",
-      ...params.context ? { context: params.context } : {},
-      results: [createPlaceholderResult(agent, task, "running")],
+      ...params.async ? { background: true } : {},
+      ...params.context === "fresh" || params.context === "fork" ? { context: params.context } : {},
+      results: [createPlaceholderResult(agent, task, "running", 0)],
       progress: [{
+        index: 0,
         agent,
+        ...sessionName ? { sessionName } : {},
         status: "running",
         task,
         recentTools: [],
@@ -148,7 +166,7 @@ export function buildSlashInitialResult(requestId, params) {
 }
 function cloneResultsWithProgress(results, progress) {
   return results.map((result, index) => {
-    const nextProgress = progress?.find((entry) => entry.index === index) ?? progress?.[index] ?? result.progress;
+    const nextProgress = progress?.find((entry) => entry.index === index || entry.index === undefined && entry.agent === result.agent) ?? result.progress;
     return nextProgress ? { ...result, progress: nextProgress } : result;
   });
 }

package/extensions/dm-subagents/src/slash/subagents-admin.js

@@ -0,0 +1,410 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  agentHasFrontmatterField,
+  discoverAgentsAll,
+  EXTRA_AGENT_DIRS_ENV,
+  frontmatterNameForConfig,
+  mergeBuiltinAgentOverride,
+  removeBuiltinAgentOverrideFields
+} from "../agents/agents.js";
+import { serializeAgent } from "../agents/agent-serializer.js";
+import { editableAgentConfig, preservedAgentFrontmatterFields } from "../agents/agent-management.js";
+import { findModelInfo, getSupportedThinkingLevels, toModelInfo } from "../shared/model-info.js";
+import { SelectorComponent } from "./selector.js";
+const ADMIN_MESSAGE_TYPE = "subagents-admin";
+const INHERIT_MODEL_CHOICE = "Default / inherit session model";
+const INHERIT_THINKING_CHOICE = "Default / inherit session thinking";
+function sourceRank(source) {
+  if (source === "project")
+    return 0;
+  if (source === "user")
+    return 1;
+  if (source === "package")
+    return 2;
+  return 3;
+}
+function allVisibleAgents(cwd) {
+  const d = discoverAgentsAll(cwd);
+  return [...d.project, ...d.user, ...d.package, ...d.builtin].filter((agent) => !agent.disabled).sort((a, b) => a.name.localeCompare(b.name) || sourceRank(a.source) - sourceRank(b.source));
+}
+function agentLabel(agent) {
+  const model = agent.model ? ` · ${agent.model}` : "";
+  return `${agent.name} [${agent.source}]${model} — ${agent.description}`;
+}
+function agentChoices(agents) {
+  const labels = agents.map(agentLabel);
+  const counts = new Map;
+  for (const label of labels)
+    counts.set(label, (counts.get(label) ?? 0) + 1);
+  return new Map(agents.map((agent, index) => {
+    const label = labels[index];
+    return [counts.get(label) === 1 ? label : `${label} · ${agent.filePath}`, agent];
+  }));
+}
+function agentSelectItems(byLabel) {
+  return [...byLabel.keys()].map((label) => ({ value: label, label }));
+}
+function agentMatches(agent, rawName) {
+  const name = rawName.trim();
+  return agent.name === name || frontmatterNameForConfig(agent) === name;
+}
+function sendAdminMessage(dm, content) {
+  dm.sendMessage({
+    customType: ADMIN_MESSAGE_TYPE,
+    content,
+    display: true
+  });
+}
+function modelFullId(model) {
+  return `${model.provider}/${model.id}`;
+}
+function liveAvailableModels(ctx) {
+  try {
+    ctx.modelRegistry.refresh?.();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(`Could not refresh the model registry; using the last loaded choices. ${message}`, "warning");
+  }
+  return ctx.modelRegistry.getAvailable();
+}
+function buildBuiltinBase(agent) {
+  return {
+    ...agent.model !== undefined ? { model: agent.model } : {},
+    ...agent.fallbackModels !== undefined ? { fallbackModels: [...agent.fallbackModels] } : {},
+    ...agent.thinking !== undefined ? { thinking: agent.thinking } : {},
+    systemPromptMode: agent.systemPromptMode,
+    inheritProjectContext: agent.inheritProjectContext,
+    inheritGlobalContext: agent.inheritGlobalContext,
+    inheritSkills: agent.inheritSkills,
+    ...agent.defaultContext !== undefined ? { defaultContext: agent.defaultContext } : {},
+    ...agent.acceptanceRole !== undefined ? { acceptanceRole: agent.acceptanceRole } : {},
+    ...agent.disabled !== undefined ? { disabled: agent.disabled } : {},
+    systemPrompt: agent.systemPrompt,
+    ...agent.skills !== undefined ? { skills: [...agent.skills] } : {},
+    ...agent.tools !== undefined ? { tools: [...agent.tools] } : {},
+    ...agent.mcpDirectTools !== undefined ? { mcpDirectTools: [...agent.mcpDirectTools] } : {},
+    ...agent.subagentOnlyExtensions !== undefined ? { subagentOnlyExtensions: [...agent.subagentOnlyExtensions] } : {},
+    ...agent.mutationTools !== undefined ? { mutationTools: [...agent.mutationTools] } : {},
+    ...agent.completionGuard !== undefined ? { completionGuard: agent.completionGuard } : {},
+    ...agent.toolBudget !== undefined ? { toolBudget: agent.toolBudget } : {}
+  };
+}
+function savesThroughSettings(agent, field) {
+  if (agent.source === "builtin")
+    return true;
+  if (agent.source === "package") {
+    if (field === "systemPrompt")
+      return false;
+    return !agentHasFrontmatterField(agent, field);
+  }
+  if (!agent.override)
+    return false;
+  if (agent.source !== agent.override.scope)
+    return false;
+  return agent[field] !== agent.override.base[field];
+}
+function isReadOnlyExtraAgent(agent) {
+  const configured = process.env[EXTRA_AGENT_DIRS_ENV];
+  if (!configured || agent.source !== "user")
+    return false;
+  const filePath = path.resolve(agent.filePath);
+  return configured.split(path.delimiter).map((dir) => dir.trim()).filter(Boolean).some((dir) => {
+    const root = path.resolve(dir);
+    const relative = path.relative(root, filePath);
+    return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  });
+}
+function readOnlyAgentMessage(agent, field) {
+  if (agent.source === "package") {
+    return `Cannot update '${agent.name}' ${field} because that field is owned by its read-only package definition.`;
+  }
+  return isReadOnlyExtraAgent(agent) ? `Cannot update '${agent.name}' because its definition in DM_SUBAGENT_EXTRA_AGENT_DIRS is read-only.` : undefined;
+}
+async function selectAgent(ctx, args) {
+  const agents = allVisibleAgents(ctx.cwd);
+  const requestedName = args.trim().split(/\s+/)[0] ?? "";
+  if (agents.length === 0)
+    return { kind: "not-found", agents, requestedName: requestedName || undefined };
+  if (requestedName) {
+    const matches = agents.filter((agent) => agentMatches(agent, requestedName));
+    if (matches.length === 1)
+      return { kind: "selected", agent: matches[0] };
+    if (matches.length > 1 && !ctx.hasUI)
+      return { kind: "ambiguous", requestedName, matches };
+    if (matches.length > 1) {
+      const byLabel = agentChoices(matches);
+      const choice = await selectFromList(ctx, `Multiple subagents named '${requestedName}'`, undefined, agentSelectItems(byLabel));
+      return choice ? { kind: "selected", agent: byLabel.get(choice) } : { kind: "cancelled" };
+    }
+    return { kind: "not-found", agents, requestedName };
+  }
+  if (!ctx.hasUI)
+    return { kind: "not-found", agents };
+  const byLabel = agentChoices(agents);
+  const choice = await selectFromList(ctx, "Select subagent", undefined, agentSelectItems(byLabel));
+  return choice ? { kind: "selected", agent: byLabel.get(choice) } : { kind: "cancelled" };
+}
+function metadataFor(agent) {
+  const tools = [...agent.tools ?? [], ...(agent.mcpDirectTools ?? []).map((tool) => `mcp:${tool}`)];
+  const lines = [
+    `Agent: ${agent.name} (${agent.source})`,
+    `Path: ${agent.filePath}`,
+    `Description: ${agent.description}`
+  ];
+  if (agent.packageName) {
+    lines.push(`Local name: ${frontmatterNameForConfig(agent)}`);
+    lines.push(`Package: ${agent.packageName}`);
+  }
+  lines.push(`Model: ${agent.model ?? "default / inherit"}`);
+  if (agent.fallbackModels?.length)
+    lines.push(`Fallback models: ${agent.fallbackModels.join(", ")}`);
+  if (agent.thinking !== undefined)
+    lines.push(`Thinking: ${agent.thinking === false ? "off" : agent.thinking}`);
+  if (tools.length)
+    lines.push(`Tools: ${tools.join(", ")}`);
+  if (agent.skills?.length)
+    lines.push(`Skills: ${agent.skills.join(", ")}`);
+  lines.push(`System prompt mode: ${agent.systemPromptMode}`);
+  lines.push(`Inherit project context: ${agent.inheritProjectContext ? "true" : "false"}`);
+  lines.push(`Inherit global context: ${agent.inheritGlobalContext ? "true" : "false"}`);
+  lines.push(`Inherit skills: ${agent.inheritSkills ? "true" : "false"}`);
+  if (agent.defaultContext)
+    lines.push(`Default context: ${agent.defaultContext}`);
+  if (agent.output)
+    lines.push(`Output: ${agent.output}`);
+  if (agent.defaultReads?.length)
+    lines.push(`Reads: ${agent.defaultReads.join(", ")}`);
+  if (agent.defaultProgress)
+    lines.push("Progress: true");
+  if (agent.maxSubagentDepth !== undefined)
+    lines.push(`Max subagent depth: ${agent.maxSubagentDepth}`);
+  if (agent.source === "builtin")
+    lines.push(`Disabled: ${agent.disabled ? "true" : "false"}`);
+  if (agent.override)
+    lines.push(`Override: ${agent.override.scope} (${agent.override.path})`);
+  if (agent.systemPrompt.trim())
+    lines.push("", "System Prompt:", agent.systemPrompt);
+  return lines.join(`
+`);
+}
+async function selectFromList(ctx, title, subtitle, items) {
+  if (typeof ctx.ui.custom === "function") {
+    const result = await ctx.ui.custom((tui, theme, kb, done) => new SelectorComponent(tui, theme, kb, { title, subtitle, items, done }), { overlay: false });
+    return result?.confirmed ? result.value : undefined;
+  }
+  const flatTitle = subtitle ? `${title}
+Current: ${subtitle}` : title;
+  const labelToValue = new Map(items.map((item) => [item.label, item.value]));
+  const choice = await ctx.ui.select(flatTitle, items.map((item) => item.value));
+  return choice ? items.find((item) => item.value === choice)?.value ?? labelToValue.get(choice) : undefined;
+}
+async function chooseModel(ctx, agent) {
+  const models = liveAvailableModels(ctx);
+  const current = agent.model ?? INHERIT_MODEL_CHOICE;
+  const items = [{ value: INHERIT_MODEL_CHOICE, label: INHERIT_MODEL_CHOICE, current: !agent.model }];
+  if (agent.model && !models.some((model) => modelFullId(model) === agent.model)) {
+    items.push({ value: agent.model, label: agent.model, current: true });
+  }
+  for (const model of models) {
+    const fullId = modelFullId(model);
+    items.push({ value: fullId, label: model.id, badge: model.provider, current: fullId === agent.model });
+  }
+  const choice = await selectFromList(ctx, `Select model for ${agent.name}`, current, items);
+  if (choice === undefined)
+    return null;
+  return choice === INHERIT_MODEL_CHOICE ? undefined : choice;
+}
+async function chooseThinking(ctx, agent) {
+  const availableModels = liveAvailableModels(ctx).map(toModelInfo);
+  const effectiveModel = agent.model ?? (ctx.model ? modelFullId(ctx.model) : undefined);
+  const modelInfo = findModelInfo(effectiveModel, availableModels, ctx.model?.provider);
+  const levels = getSupportedThinkingLevels(modelInfo);
+  const current = agent.thinking === false ? "off" : agent.thinking ?? INHERIT_THINKING_CHOICE;
+  const values = [INHERIT_THINKING_CHOICE, ...levels];
+  if (current !== INHERIT_THINKING_CHOICE && !values.includes(current))
+    values.splice(1, 0, current);
+  const modelNote = agent.model ? `Model: ${agent.model}` : effectiveModel ? `Session model: ${effectiveModel}` : "Model: default / inherit";
+  const items = values.map((value) => ({ value, label: value, current: value === current }));
+  const choice = await selectFromList(ctx, `Select thinking level for ${agent.name}`, `${modelNote} · ${current}`, items);
+  if (choice === undefined)
+    return null;
+  return choice === INHERIT_THINKING_CHOICE ? undefined : choice;
+}
+async function chooseOverrideScope(ctx, agent) {
+  if (agent.override?.scope)
+    return agent.override.scope;
+  const d = discoverAgentsAll(ctx.cwd);
+  if (!d.projectSettingsPath || !ctx.hasUI)
+    return "user";
+  const choice = await ctx.ui.select(`Save builtin override for ${agent.name}`, ["user", "project"]);
+  return choice === "user" || choice === "project" ? choice : undefined;
+}
+function persistSettingsField(ctx, agent, scope, field, value) {
+  const base = agent.override?.base ?? buildBuiltinBase(agent);
+  if (value === undefined || value === base[field]) {
+    return {
+      filePath: removeBuiltinAgentOverrideFields(ctx.cwd, agent.name, scope, [field]).path,
+      overridden: false
+    };
+  }
+  return {
+    filePath: mergeBuiltinAgentOverride(ctx.cwd, agent.name, scope, { [field]: value }),
+    overridden: true
+  };
+}
+async function saveAgentModel(ctx, agent, selectedModel) {
+  if (savesThroughSettings(agent, "model")) {
+    const scope = await chooseOverrideScope(ctx, agent);
+    if (!scope)
+      return null;
+    const { filePath, overridden } = persistSettingsField(ctx, agent, scope, "model", selectedModel);
+    return overridden ? `Saved ${scope} settings override for '${agent.name}' with model '${selectedModel}' in ${filePath}.` : `Cleared model settings override for '${agent.name}' in ${filePath}.`;
+  }
+  const readOnlyMessage = readOnlyAgentMessage(agent, "model");
+  if (readOnlyMessage)
+    return readOnlyMessage;
+  const updated = editableAgentConfig(agent);
+  if (selectedModel === undefined)
+    delete updated.model;
+  else
+    updated.model = selectedModel;
+  fs.writeFileSync(updated.filePath, serializeAgent(updated, {
+    preserveFrontmatterFields: preservedAgentFrontmatterFields(agent, { model: selectedModel })
+  }), "utf-8");
+  return selectedModel ? `Updated '${agent.name}' model to '${selectedModel}' in ${updated.filePath}.` : `Cleared '${agent.name}' model in ${updated.filePath}.`;
+}
+async function saveAgentThinking(ctx, agent, selectedThinking) {
+  if (savesThroughSettings(agent, "thinking")) {
+    const scope = await chooseOverrideScope(ctx, agent);
+    if (!scope)
+      return null;
+    const { filePath, overridden } = persistSettingsField(ctx, agent, scope, "thinking", selectedThinking);
+    return overridden ? `Saved ${scope} settings override for '${agent.name}' with thinking '${selectedThinking}' in ${filePath}.` : `Cleared thinking settings override for '${agent.name}' in ${filePath}.`;
+  }
+  const readOnlyMessage = readOnlyAgentMessage(agent, "thinking");
+  if (readOnlyMessage)
+    return readOnlyMessage;
+  const updated = editableAgentConfig(agent);
+  if (selectedThinking === undefined)
+    delete updated.thinking;
+  else
+    updated.thinking = selectedThinking;
+  fs.writeFileSync(updated.filePath, serializeAgent(updated, {
+    preserveFrontmatterFields: preservedAgentFrontmatterFields(agent, { thinking: selectedThinking })
+  }), "utf-8");
+  return selectedThinking ? `Updated '${agent.name}' thinking to '${selectedThinking}' in ${updated.filePath}.` : `Cleared '${agent.name}' thinking in ${updated.filePath}.`;
+}
+function metadataSummary(agent) {
+  return [
+    `Source: ${agent.source}`,
+    `Model: ${agent.model ?? "default / inherit"}`,
+    `Thinking: ${agent.thinking === false ? "off" : agent.thinking ?? "default / inherit"}`
+  ].join(" · ");
+}
+async function saveAgentSystemPrompt(ctx, agent, systemPrompt) {
+  const nextPrompt = systemPrompt.replace(/\s+$/, "");
+  if (savesThroughSettings(agent, "systemPrompt")) {
+    const scope = await chooseOverrideScope(ctx, agent);
+    if (!scope)
+      return null;
+    const { filePath, overridden } = persistSettingsField(ctx, agent, scope, "systemPrompt", nextPrompt);
+    return overridden ? `Saved ${scope} settings override for '${agent.name}' system prompt in ${filePath}.` : `Cleared system prompt settings override for '${agent.name}' in ${filePath}.`;
+  }
+  const readOnlyMessage = readOnlyAgentMessage(agent, "systemPrompt");
+  if (readOnlyMessage)
+    return readOnlyMessage;
+  const updated = { ...editableAgentConfig(agent), systemPrompt: nextPrompt };
+  fs.writeFileSync(updated.filePath, serializeAgent(updated, {
+    preserveFrontmatterFields: preservedAgentFrontmatterFields(agent, { systemPrompt: nextPrompt })
+  }), "utf-8");
+  return `Updated '${agent.name}' system prompt in ${updated.filePath}.`;
+}
+async function editSystemPrompt(ctx, agent) {
+  if (!savesThroughSettings(agent, "systemPrompt")) {
+    const readOnlyMessage = readOnlyAgentMessage(agent, "systemPrompt");
+    if (readOnlyMessage)
+      return readOnlyMessage;
+  }
+  const edited = await ctx.ui.editor(`Edit '${agent.name}' system prompt`, agent.systemPrompt ?? "");
+  if (edited === undefined)
+    return null;
+  if (edited.replace(/\s+$/, "") === (agent.systemPrompt ?? "").replace(/\s+$/, "")) {
+    return `System prompt for '${agent.name}' left unchanged.`;
+  }
+  return saveAgentSystemPrompt(ctx, agent, edited);
+}
+export async function openSubagentsAdmin(dm, ctx, args = "") {
+  const selection = await selectAgent(ctx, args);
+  if (selection.kind === "cancelled")
+    return;
+  if (selection.kind === "ambiguous") {
+    sendAdminMessage(dm, `Subagent '${selection.requestedName}' is ambiguous. Choose a scope in interactive mode:
+${selection.matches.map((agent) => `- ${agent.source}: ${agent.filePath}`).join(`
+`)}`);
+    return;
+  }
+  if (selection.kind === "not-found") {
+    const text = selection.requestedName ? `Subagent '${selection.requestedName}' not found.
+
+Available subagents:
+${selection.agents.map((agent) => `- ${agent.name} (${agent.source})`).join(`
+`) || "- (none)"}` : `Available subagents:
+${selection.agents.map((agent) => `- ${agent.name} (${agent.source})`).join(`
+`) || "- (none)"}`;
+    sendAdminMessage(dm, text);
+    return;
+  }
+  const agent = selection.agent;
+  if (!ctx.hasUI) {
+    sendAdminMessage(dm, metadataFor(agent));
+    return;
+  }
+  const requestedAction = args.trim().split(/\s+/)[1]?.toLowerCase();
+  let action;
+  if (requestedAction === "model")
+    action = "Change model";
+  else if (requestedAction === "thinking")
+    action = "Change thinking level";
+  else if (requestedAction === "prompt" || requestedAction === "system-prompt" || requestedAction === "edit")
+    action = "Edit system prompt";
+  else if (requestedAction === "details" || requestedAction === "info")
+    action = "Show details";
+  if (!action) {
+    action = await ctx.ui.select(`Administer ${agent.name}
+${metadataSummary(agent)}`, ["Change model", "Change thinking level", "Edit system prompt", "Show details", "Done"]);
+  }
+  try {
+    if (action === "Change model") {
+      const selectedModel = await chooseModel(ctx, agent);
+      if (selectedModel === null)
+        return;
+      const message = await saveAgentModel(ctx, agent, selectedModel);
+      if (message === null)
+        return;
+      ctx.ui.notify(message, "info");
+      sendAdminMessage(dm, message);
+    } else if (action === "Change thinking level") {
+      const selectedThinking = await chooseThinking(ctx, agent);
+      if (selectedThinking === null)
+        return;
+      const message = await saveAgentThinking(ctx, agent, selectedThinking);
+      if (message === null)
+        return;
+      ctx.ui.notify(message, "info");
+      sendAdminMessage(dm, message);
+    } else if (action === "Edit system prompt") {
+      const message = await editSystemPrompt(ctx, agent);
+      if (message === null)
+        return;
+      ctx.ui.notify(message, "info");
+      sendAdminMessage(dm, message);
+    } else if (action === "Show details") {
+      sendAdminMessage(dm, metadataFor(agent));
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(message, "error");
+    sendAdminMessage(dm, `Failed to update '${agent.name}': ${message}`);
+  }
+}