@desplega.ai/agent-swarm 1.77.0 → 1.77.2

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.77.0",
+    "version": "1.77.2",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [
@@ -448,6 +448,73 @@
         }
       }
     },
+    "/api/agents/{id}/runtime": {
+      "patch": {
+        "summary": "Update an agent's runtime harness and default model",
+        "description": "Updates `agents.harness_provider` and upserts agent-scoped `swarm_config` rows for HARNESS_PROVIDER and MODEL_OVERRIDE. The settings apply to future provider sessions.",
+        "tags": [
+          "Agents"
+        ],
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "parameters": [
+          {
+            "schema": {
+              "type": "string"
+            },
+            "required": true,
+            "name": "id",
+            "in": "path"
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "harness_provider": {
+                    "type": "string",
+                    "enum": [
+                      "claude",
+                      "codex",
+                      "pi",
+                      "opencode"
+                    ]
+                  },
+                  "model": {
+                    "type": "string",
+                    "minLength": 1
+                  },
+                  "allow_custom_model": {
+                    "type": "boolean",
+                    "default": false
+                  }
+                },
+                "required": [
+                  "harness_provider",
+                  "model"
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Updated agent row"
+          },
+          "400": {
+            "description": "Validation error"
+          },
+          "404": {
+            "description": "Agent not found"
+          }
+        }
+      }
+    },
     "/api/agents/{id}/name": {
       "put": {
         "summary": "Update agent name",
@@ -797,6 +864,59 @@
                           "testedAt"
                         ]
                       },
+                      "latestModel": {
+                        "type": [
+                          "object",
+                          "null"
+                        ],
+                        "properties": {
+                          "model": {
+                            "type": "string",
+                            "minLength": 1
+                          },
+                          "source": {
+                            "type": "string",
+                            "enum": [
+                              "task",
+                              "agent_config",
+                              "adapter_default",
+                              "custom"
+                            ]
+                          },
+                          "taskId": {
+                            "type": [
+                              "string",
+                              "null"
+                            ],
+                            "default": null
+                          },
+                          "harnessProvider": {
+                            "type": [
+                              "string",
+                              "null"
+                            ],
+                            "enum": [
+                              "claude",
+                              "codex",
+                              "pi",
+                              "devin",
+                              "claude-managed",
+                              "opencode",
+                              null
+                            ],
+                            "default": null
+                          },
+                          "reportedAt": {
+                            "type": "number"
+                          }
+                        },
+                        "default": null,
+                        "required": [
+                          "model",
+                          "source",
+                          "reportedAt"
+                        ]
+                      },
                       "reportedAt": {
                         "type": "number"
                       },
@@ -813,11 +933,57 @@
                       "ready",
                       "reportedAt"
                     ]
+                  },
+                  "latest_model": {
+                    "type": "object",
+                    "properties": {
+                      "model": {
+                        "type": "string",
+                        "minLength": 1
+                      },
+                      "source": {
+                        "type": "string",
+                        "enum": [
+                          "task",
+                          "agent_config",
+                          "adapter_default",
+                          "custom"
+                        ]
+                      },
+                      "taskId": {
+                        "type": [
+                          "string",
+                          "null"
+                        ],
+                        "default": null
+                      },
+                      "harnessProvider": {
+                        "type": [
+                          "string",
+                          "null"
+                        ],
+                        "enum": [
+                          "claude",
+                          "codex",
+                          "pi",
+                          "devin",
+                          "claude-managed",
+                          "opencode",
+                          null
+                        ],
+                        "default": null
+                      },
+                      "reportedAt": {
+                        "type": "number"
+                      }
+                    },
+                    "required": [
+                      "model",
+                      "source",
+                      "reportedAt"
+                    ]
                   }
-                },
-                "required": [
-                  "ready"
-                ]
+                }
               }
             }
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.77.0",
+  "version": "1.77.2",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/commands/provider-credentials.ts

@@ -25,7 +25,7 @@ import { checkDevinCredentials } from "../providers/devin-adapter";
 import { checkOpencodeCredentials } from "../providers/opencode-adapter";
 import { checkPiMonoCredentials } from "../providers/pi-mono-adapter";
 import type { CredCheckOptions, CredStatus } from "../providers/types";
-import type { AgentCredStatus } from "../types";
+import type { AgentCredStatus, AgentLatestModel, ProviderName } from "../types";
 import { scrubSecrets } from "../utils/secret-scrubber";
 
 export type SupportedProvider = "claude" | "claude-managed" | "codex" | "devin" | "opencode" | "pi";
@@ -392,6 +392,7 @@ export async function buildCredStatusReport(
     satisfiedBy: presence.satisfiedBy ?? null,
     hint: presence.hint ?? null,
     liveTest,
+    latestModel: null,
     reportedAt: Date.now(),
     reportKind: kind,
   };
@@ -432,3 +433,53 @@ export async function reportCredStatus(
     console.warn(`[cred-status] POST failed (non-fatal): ${err}`);
   }
 }
+
+export async function reportLatestModel(
+  apiUrl: string,
+  apiKey: string,
+  agentId: string,
+  latestModel: AgentLatestModel,
+): Promise<void> {
+  try {
+    await fetch(`${apiUrl}/api/agents/${encodeURIComponent(agentId)}/credential-status`, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "X-Agent-ID": agentId,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        latest_model: latestModel,
+      }),
+    });
+  } catch (err) {
+    console.warn(`[latest-model] POST failed (non-fatal): ${err}`);
+  }
+}
+
+export function buildLatestModelReport(opts: {
+  model: string;
+  taskModel?: string;
+  configModel?: string;
+  taskId?: string;
+  harnessProvider: ProviderName;
+}): AgentLatestModel | null {
+  const model = opts.model.trim();
+  if (!model) return null;
+  const taskModel = opts.taskModel?.trim();
+  const configModel = opts.configModel?.trim();
+  return {
+    model,
+    source:
+      taskModel && model === taskModel
+        ? "task"
+        : configModel && model === configModel
+          ? "agent_config"
+          : taskModel || configModel
+            ? "custom"
+            : "adapter_default",
+    taskId: opts.taskId ?? null,
+    harnessProvider: opts.harnessProvider,
+    reportedAt: Date.now(),
+  };
+}

package/src/commands/runner.ts

@@ -33,8 +33,10 @@ import { interpolate } from "../workflows/template.ts";
 import { awaitCredentials, BootMaxWaitExceededError, EX_CONFIG } from "./credential-wait.ts";
 import {
   buildCredStatusReport,
+  buildLatestModelReport,
   isCredCheckDisabled,
   reportCredStatus,
+  reportLatestModel,
 } from "./provider-credentials.ts";
 // Side-effect import: registers runner trigger/resumption templates
 import "./templates.ts";
@@ -415,13 +417,19 @@ export function humanizeToolName(name: string): 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 maybeMcpServer = typeof a?.server === "string" ? a.server : undefined;
+  const maybeMcpTool = typeof a?.tool === "string" ? a.tool : undefined;
+  const effectiveToolName =
+    maybeMcpServer && maybeMcpTool ? `mcp__${maybeMcpServer}__${maybeMcpTool}` : toolName;
+  if (SKIP_PROGRESS_TOOLS.has(effectiveToolName)) return null;
+
   // Normalize: pi-mono uses lowercase ("read"), Claude uses PascalCase ("Read")
   const normalized =
-    toolName.startsWith("mcp__") || toolName.includes("_")
-      ? toolName
-      : toolName.charAt(0).toUpperCase() + toolName.slice(1);
+    effectiveToolName.startsWith("mcp__") || effectiveToolName.includes("_")
+      ? effectiveToolName
+      : effectiveToolName.charAt(0).toUpperCase() + effectiveToolName.slice(1);
 
-  const a = args as Record<string, unknown>;
   const shortPath = (p: unknown) => {
     if (typeof p !== "string") return "";
     // Show last 2 path segments for readability
@@ -450,8 +458,8 @@ export function toolCallToProgress(toolName: string, args: unknown): string | nu
       return `⚙️ Running /${a.skill}`;
     default: {
       // MCP tools: mcp__server__tool
-      if (toolName.startsWith("mcp__")) {
-        const parts = toolName.split("__");
+      if (effectiveToolName.startsWith("mcp__")) {
+        const parts = effectiveToolName.split("__");
         if (parts.length >= 3) {
           const server = parts[1];
           const tool = parts.slice(2).join("__");
@@ -465,8 +473,18 @@ export function toolCallToProgress(toolName: string, args: unknown): string | nu
           // Other MCP servers: "🔌 server: Humanized tool"
           return `🔌 ${server}: ${humanizeToolName(tool)}`;
         }
-        return `🔌 ${toolName}`;
+        return `🔌 ${effectiveToolName}`;
+      }
+
+      // Pi-mono exposes tools from the built-in swarm MCP endpoint as bare
+      // names ("store-progress", "send-task", ...), not as mcp__ names.
+      // Treat those names as agent-swarm tools so activity stays readable.
+      if (toolName.includes("-")) {
+        const label = SWARM_TOOL_LABELS[toolName];
+        if (label === null) return null;
+        if (label) return label;
       }
+
       return `🔧 ${toolName}`;
     }
   }
@@ -1736,6 +1754,7 @@ async function spawnProviderProcess(
     iteration: number;
     taskId?: string;
     model?: string;
+    harnessProvider: ProviderName;
     cwd?: string;
     vcsRepo?: string;
   },
@@ -1767,7 +1786,8 @@ async function spawnProviderProcess(
     process.env.AGENT_FS_SHARED_ORG_ID = freshEnv.AGENT_FS_SHARED_ORG_ID as string;
   }
 
-  const model = opts.model || (freshEnv.MODEL_OVERRIDE as string) || "";
+  const configModel = (freshEnv.MODEL_OVERRIDE as string | undefined) || "";
+  const model = opts.model || configModel || "";
 
   const config: ProviderSessionConfig = {
     prompt: opts.prompt,
@@ -1787,6 +1807,18 @@ async function spawnProviderProcess(
   };
 
   const session = await adapter.createSession(config);
+  const initialModelReport = buildLatestModelReport({
+    model,
+    taskModel: opts.model,
+    configModel,
+    taskId: realTaskId,
+    harnessProvider: opts.harnessProvider,
+  });
+  if (initialModelReport) {
+    reportLatestModel(opts.apiUrl, opts.apiKey, opts.agentId, initialModelReport).catch((err) =>
+      console.warn(`[runner] Failed to report latest model: ${err}`),
+    );
+  }
 
   let oauthSelection: CredentialSelection | undefined;
   if (adapter.name === "codex" && credentialSelections.length === 0) {
@@ -1944,6 +1976,20 @@ async function spawnProviderProcess(
         break;
       }
       case "result":
+        {
+          const latestModel = buildLatestModelReport({
+            model: event.cost.model,
+            taskModel: opts.model,
+            configModel,
+            taskId: realTaskId,
+            harnessProvider: opts.harnessProvider,
+          });
+          if (latestModel) {
+            reportLatestModel(opts.apiUrl, opts.apiKey, opts.agentId, latestModel).catch((err) =>
+              console.warn(`[runner] Failed to report latest model: ${err}`),
+            );
+          }
+        }
         // Cost save is handled in waitForCompletion().then() to ensure
         // it completes before the process exits (fire-and-forget here
         // races with container shutdown).
@@ -3190,6 +3236,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               iteration,
               taskId: task.id,
               model: (task as { model?: string }).model,
+              harnessProvider: state.harnessProvider,
               cwd: resumeCwd,
               vcsRepo: task.vcsRepo,
             },
@@ -3589,6 +3636,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               iteration,
               taskId: trigger.taskId,
               model: taskModel,
+              harnessProvider: state.harnessProvider,
               cwd: effectiveCwd,
               vcsRepo: taskVcsRepo,
             },

package/src/http/agents.ts

@@ -21,7 +21,12 @@ import {
   updateAgentStatus,
   upsertSwarmConfig,
 } from "../be/db";
-import { AgentCredStatusSchema, ProviderNameSchema } from "../types";
+import {
+  AgentCredStatusSchema,
+  AgentLatestModelSchema,
+  type ProviderName,
+  ProviderNameSchema,
+} from "../types";
 import { route } from "./route-def";
 import { agentWithCapacity, json, jsonError } from "./utils";
 
@@ -74,6 +79,29 @@ const setAgentHarnessProviderRoute = route({
   },
 });
 
+const LocalHarnessProviderSchema = z.enum(["claude", "codex", "pi", "opencode"]);
+
+const updateAgentRuntimeRoute = route({
+  method: "patch",
+  path: "/api/agents/{id}/runtime",
+  pattern: ["api", "agents", null, "runtime"],
+  summary: "Update an agent's runtime harness and default model",
+  description:
+    "Updates `agents.harness_provider` and upserts agent-scoped `swarm_config` rows for HARNESS_PROVIDER and MODEL_OVERRIDE. The settings apply to future provider sessions.",
+  tags: ["Agents"],
+  params: z.object({ id: z.string() }),
+  body: z.object({
+    harness_provider: LocalHarnessProviderSchema,
+    model: z.string().trim().min(1),
+    allow_custom_model: z.boolean().optional().default(false),
+  }),
+  responses: {
+    200: { description: "Updated agent row" },
+    400: { description: "Validation error" },
+    404: { description: "Agent not found" },
+  },
+});
+
 const listAgents = route({
   method: "get",
   path: "/api/agents",
@@ -175,7 +203,7 @@ const getAgent = route({
 // ─── Credential-status (Phase 3 + 4 of the credential safe-loop plan) ───────
 
 const credentialStatusBody = z.object({
-  ready: z.boolean(),
+  ready: z.boolean().optional(),
   /** Env-var names (or absolute file paths) the worker is blocked on. Empty/null when ready. */
   missing: z.array(z.string()).optional().nullable(),
   /**
@@ -185,6 +213,11 @@ const credentialStatusBody = z.object({
    * reads the row instead of running its own check.
    */
   cred_status: AgentCredStatusSchema.optional().nullable(),
+  /**
+   * Worker-reported latest model telemetry. Optional and merge-only: when sent
+   * without `cred_status`, the API preserves existing readiness/live-test data.
+   */
+  latest_model: AgentLatestModelSchema.optional(),
 });
 
 const updateAgentCredentialStatusRoute = route({
@@ -468,6 +501,41 @@ export async function handleAgentsRest(
     return true;
   }
 
+  if (updateAgentRuntimeRoute.match(req.method, pathSegments)) {
+    const parsed = await updateAgentRuntimeRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const agent = getDb().transaction(() => {
+      const updated = setAgentHarnessProvider(
+        parsed.params.id,
+        parsed.body.harness_provider as ProviderName,
+      );
+      if (!updated) return null;
+      upsertSwarmConfig({
+        scope: "agent",
+        scopeId: parsed.params.id,
+        key: "HARNESS_PROVIDER",
+        value: parsed.body.harness_provider,
+        description: "Set via PATCH /api/agents/{id}/runtime",
+      });
+      upsertSwarmConfig({
+        scope: "agent",
+        scopeId: parsed.params.id,
+        key: "MODEL_OVERRIDE",
+        value: parsed.body.model,
+        description: parsed.body.allow_custom_model
+          ? "Custom model set via PATCH /api/agents/{id}/runtime"
+          : "Set via PATCH /api/agents/{id}/runtime",
+      });
+      return updated;
+    })();
+    if (!agent) {
+      jsonError(res, "Agent not found", 404);
+      return true;
+    }
+    json(res, agentWithCapacity(agent));
+    return true;
+  }
+
   // Bulk credential-status MUST be matched BEFORE single-agent routes — the
   // path "api/agents/credential-status" otherwise looks like an agent id.
   if (listCredentialStatusRoute.match(req.method, pathSegments)) {
@@ -498,11 +566,19 @@ export async function handleAgentsRest(
       queryParams,
     );
     if (!parsed) return true;
-    const agent = updateAgentCredentialState(
-      parsed.params.id,
-      parsed.body.ready,
-      parsed.body.missing ?? null,
-    );
+    const existing = getAgentById(parsed.params.id);
+    if (!existing) {
+      jsonError(res, "Agent not found", 404);
+      return true;
+    }
+    const agent =
+      parsed.body.ready !== undefined
+        ? (updateAgentCredentialState(
+            parsed.params.id,
+            parsed.body.ready,
+            parsed.body.missing ?? null,
+          ) ?? existing)
+        : existing;
     if (!agent) {
       jsonError(res, "Agent not found", 404);
       return true;
@@ -510,10 +586,36 @@ export async function handleAgentsRest(
     // Phase 055: persist the richer worker-reported snapshot when sent.
     // We accept `null` to explicitly clear (e.g. on harness change), and
     // `undefined` to leave the existing row value untouched.
-    const finalAgent =
-      parsed.body.cred_status !== undefined
-        ? (updateAgentCredStatus(parsed.params.id, parsed.body.cred_status ?? null) ?? agent)
-        : agent;
+    let finalAgent = agent;
+    if (parsed.body.cred_status !== undefined) {
+      const nextStatus = parsed.body.cred_status
+        ? {
+            ...parsed.body.cred_status,
+            latestModel:
+              parsed.body.latest_model ??
+              parsed.body.cred_status.latestModel ??
+              agent.credStatus?.latestModel ??
+              null,
+          }
+        : null;
+      finalAgent = updateAgentCredStatus(parsed.params.id, nextStatus) ?? agent;
+    } else if (parsed.body.latest_model) {
+      const current = agent.credStatus ?? {
+        ready: parsed.body.ready ?? true,
+        missing: parsed.body.missing ?? [],
+        satisfiedBy: null,
+        hint: null,
+        liveTest: null,
+        latestModel: null,
+        reportedAt: parsed.body.latest_model.reportedAt,
+        reportKind: "post_task" as const,
+      };
+      finalAgent =
+        updateAgentCredStatus(parsed.params.id, {
+          ...current,
+          latestModel: parsed.body.latest_model,
+        }) ?? agent;
+    }
     json(res, agentWithCapacity(finalAgent));
     return true;
   }

package/src/tests/agents-harness-provider.test.ts

@@ -28,7 +28,7 @@ import {
 import { handleAgentRegister, handleAgentsRest } from "../http/agents";
 
 const TEST_DB_PATH = "./test-agents-harness-provider.sqlite";
-const TEST_PORT = 13059;
+const TEST_PORT = 13059 + (process.pid % 1000);
 
 async function removeDbFiles(path: string): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {
@@ -42,7 +42,7 @@ async function removeDbFiles(path: string): Promise<void> {
 
 function makeTestServer(): Server {
   return createHttpServer(async (req, res) => {
-    const url = new URL(req.url ?? "/", `http://localhost:${TEST_PORT}`);
+    const url = new URL(req.url ?? "/", "http://localhost");
     const pathSegments = url.pathname.split("/").filter(Boolean);
     const queryParams = url.searchParams;
     const myAgentId = (req.headers["x-agent-id"] as string | undefined) ?? undefined;
@@ -331,3 +331,44 @@ describe("PATCH /api/agents/:id/harness-provider", () => {
     expect(rows2.filter((r) => r.key === "HARNESS_PROVIDER")).toHaveLength(1);
   });
 });
+
+describe("PATCH /api/agents/:id/runtime", () => {
+  test("updates harness_provider and agent-scoped runtime config rows", async () => {
+    const a = createAgent({
+      name: "runtime-target-1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const res = await fetch(`${baseUrl}/api/agents/${a.id}/runtime`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "codex", model: "gpt-5.4" }),
+    });
+    expect(res.status).toBe(200);
+
+    const row = getAgentById(a.id);
+    expect(row?.harnessProvider).toBe("codex");
+
+    const rows = getSwarmConfigs({ scope: "agent", scopeId: a.id });
+    expect(rows.find((r) => r.key === "HARNESS_PROVIDER")?.value).toBe("codex");
+    expect(rows.find((r) => r.key === "MODEL_OVERRIDE")?.value).toBe("gpt-5.4");
+  });
+
+  test("rejects non-local harnesses for runtime editing", async () => {
+    const a = createAgent({
+      name: "runtime-target-2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const res = await fetch(`${baseUrl}/api/agents/${a.id}/runtime`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "devin", model: "devin" }),
+    });
+    expect(res.status).toBe(400);
+  });
+});

package/src/tests/credential-status-api.test.ts

@@ -20,7 +20,7 @@ import { getPathSegments, parseQueryParams } from "../http/utils";
  */
 
 const TEST_DB_PATH = "./test-credential-status-api.sqlite";
-const TEST_PORT = 13041;
+const TEST_PORT = 13041 + (process.pid % 1000);
 
 function createTestServer(): Server {
   return createHttpServer(async (req, res) => {
@@ -220,4 +220,43 @@ describe("Phase 4 — credential-status HTTP endpoints", () => {
     });
     expect(resp.status).toBe(400);
   });
+
+  test("PUT /credential-status merges latest_model without clobbering readiness", async () => {
+    const snapshot = {
+      ready: true,
+      missing: [],
+      satisfiedBy: "env" as const,
+      hint: null,
+      liveTest: { ok: true, error: null, latency_ms: 45, testedAt: Date.now() },
+      reportedAt: Date.now(),
+      reportKind: "boot" as const,
+    };
+    await fetch(`${baseUrl}/api/agents/${readyAgentId}/credential-status`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ready: true, missing: [], cred_status: snapshot }),
+    });
+
+    const modelReport = {
+      model: "gpt-5.4",
+      source: "agent_config" as const,
+      taskId: "task-123",
+      harnessProvider: "codex" as const,
+      reportedAt: Date.now(),
+    };
+    const put = await fetch(`${baseUrl}/api/agents/${readyAgentId}/credential-status`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ latest_model: modelReport }),
+    });
+    expect(put.status).toBe(200);
+
+    const get = await fetch(`${baseUrl}/api/agents/${readyAgentId}/credential-status`);
+    const body = (await get.json()) as {
+      credStatus: typeof snapshot & { latestModel?: typeof modelReport };
+    };
+    expect(body.credStatus.ready).toBe(true);
+    expect(body.credStatus.liveTest).toMatchObject({ ok: true, latency_ms: 45 });
+    expect(body.credStatus.latestModel).toMatchObject({ model: "gpt-5.4", source: "agent_config" });
+  });
 });

package/src/tests/tool-call-progress.test.ts

@@ -175,6 +175,50 @@ describe("toolCallToProgress", () => {
     expect(result).toBe("🔌 context7: Query docs");
   });
 
+  // --- Provider-normalized MCP variants ---
+
+  test("bare agent-swarm store-progress is skipped", () => {
+    expect(toolCallToProgress("store-progress", {})).toBeNull();
+  });
+
+  test("bare agent-swarm send-task has pretty label", () => {
+    const result = toolCallToProgress("send-task", {});
+    expect(result).toBe("📤 Delegating task");
+  });
+
+  test("bare agent-swarm db-query has pretty label", () => {
+    const result = toolCallToProgress("db-query", {});
+    expect(result).toBe("🗃️ Querying database");
+  });
+
+  test("codex MCP args with agent-swarm server use pretty labels", () => {
+    const result = toolCallToProgress("send-task", {
+      server: "agent-swarm",
+      tool: "send-task",
+      arguments: { task: "ping" },
+    });
+    expect(result).toBe("📤 Delegating task");
+  });
+
+  test("codex MCP args with agent-swarm store-progress are skipped", () => {
+    expect(
+      toolCallToProgress("store-progress", {
+        server: "agent-swarm",
+        tool: "store-progress",
+        arguments: { status: "completed" },
+      }),
+    ).toBeNull();
+  });
+
+  test("codex MCP args with external server keep server prefix", () => {
+    const result = toolCallToProgress("list-issues", {
+      server: "linear",
+      tool: "list-issues",
+      arguments: {},
+    });
+    expect(result).toBe("🔌 linear: List issues");
+  });
+
   // --- Short path helper (tested implicitly) ---
 
   test("Read with short path (<=2 segments) keeps full path", () => {

package/src/types.ts

@@ -386,12 +386,22 @@ export const AgentCredStatusLiveTestSchema = z.object({
 });
 export type AgentCredStatusLiveTest = z.infer<typeof AgentCredStatusLiveTestSchema>;
 
+export const AgentLatestModelSchema = z.object({
+  model: z.string().min(1),
+  source: z.enum(["task", "agent_config", "adapter_default", "custom"]),
+  taskId: z.string().nullable().default(null),
+  harnessProvider: ProviderNameSchema.nullable().default(null),
+  reportedAt: z.number(), // unix ms
+});
+export type AgentLatestModel = z.infer<typeof AgentLatestModelSchema>;
+
 export const AgentCredStatusSchema = z.object({
   ready: z.boolean(),
   missing: z.array(z.string()).default([]),
   satisfiedBy: z.enum(["env", "file", "side-effect-pending"]).nullable().default(null),
   hint: z.string().nullable().default(null),
   liveTest: AgentCredStatusLiveTestSchema.nullable().default(null),
+  latestModel: AgentLatestModelSchema.nullable().default(null),
   reportedAt: z.number(), // unix ms
   reportKind: z.enum(["boot", "post_task"]).default("boot"),
 });