@desplega.ai/agent-swarm 1.84.1 → 1.85.0

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.84.1",
+    "version": "1.85.0",
     "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": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.84.1",
+  "version": "1.85.0",
   "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/be/db-queries/oauth.ts

@@ -180,3 +180,36 @@ export function isTokenExpiringSoon(provider: string, bufferMs = 5 * 60 * 1000):
   const expiresAt = new Date(tokens.expiresAt).getTime();
   return expiresAt - Date.now() < bufferMs;
 }
+
+// ── OAuth Refresh Locks ──
+
+export function acquireOAuthRefreshLock(provider: string, ttlMs: number): string | null {
+  const owner = crypto.randomUUID();
+  const now = Date.now();
+  const expiresAt = new Date(now + ttlMs).toISOString();
+  const nowIso = new Date(now).toISOString();
+
+  getDb()
+    .query(
+      `INSERT INTO oauth_refresh_locks (provider, owner, expiresAt, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(provider) DO UPDATE SET
+         owner = excluded.owner,
+         expiresAt = excluded.expiresAt,
+         updatedAt = excluded.updatedAt
+       WHERE oauth_refresh_locks.expiresAt <= ?`,
+    )
+    .run(provider, owner, expiresAt, nowIso, nowIso, nowIso);
+
+  const row = getDb()
+    .query("SELECT owner FROM oauth_refresh_locks WHERE provider = ?")
+    .get(provider) as { owner: string } | null;
+
+  return row?.owner === owner ? owner : null;
+}
+
+export function releaseOAuthRefreshLock(provider: string, owner: string): void {
+  getDb()
+    .query("DELETE FROM oauth_refresh_locks WHERE provider = ? AND owner = ?")
+    .run(provider, owner);
+}

package/src/be/db.ts

@@ -1012,6 +1012,7 @@ type AgentTaskRow = {
   swarmVersion: string | null;
   provider: string | null;
   providerMeta: string | null;
+  totalCostUsd?: number | null;
 };
 
 function rowToAgentTask(row: AgentTaskRow): AgentTask {
@@ -1075,6 +1076,7 @@ function rowToAgentTask(row: AgentTaskRow): AgentTask {
     swarmVersion: row.swarmVersion ?? undefined,
     provider: (row.provider as ProviderName | null) ?? undefined,
     providerMeta: parseProviderMeta(row.provider as ProviderName | null, row.providerMeta),
+    totalCostUsd: row.totalCostUsd ?? undefined,
   };
 }
 
@@ -1110,6 +1112,7 @@ function rowToAgentTaskSummary(row: AgentTaskRow): AgentTaskSummary {
     lastUpdatedAt: t.lastUpdatedAt,
     finishedAt: t.finishedAt,
     peakContextPercent: t.peakContextPercent,
+    totalCostUsd: t.totalCostUsd,
   };
 }
 
@@ -1504,7 +1507,10 @@ export function getAllTasks(
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const limit = filters?.limit ?? 25;
   const offset = filters?.offset ?? 0;
-  const query = `SELECT * FROM agent_tasks ${whereClause} ORDER BY lastUpdatedAt DESC, priority DESC LIMIT ${limit} OFFSET ${offset}`;
+  const query = `SELECT agent_tasks.*,
+    (SELECT SUM(totalCostUsd) FROM session_costs WHERE session_costs.taskId = agent_tasks.id) AS totalCostUsd
+    FROM agent_tasks ${whereClause}
+    ORDER BY lastUpdatedAt DESC, priority DESC LIMIT ${limit} OFFSET ${offset}`;
 
   const rows = getDb()
     .prepare<AgentTaskRow, (string | AgentTaskStatus)[]>(query)

package/src/be/migrations/077_oauth_refresh_locks.sql

@@ -0,0 +1,8 @@
+-- Cross-process mutex for OAuth refresh-token rotation.
+CREATE TABLE IF NOT EXISTS oauth_refresh_locks (
+  provider  TEXT PRIMARY KEY,
+  owner     TEXT NOT NULL,
+  expiresAt TEXT NOT NULL,
+  createdAt TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  updatedAt TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);

package/src/commands/runner.ts

@@ -48,6 +48,7 @@ import { prettyPrintLine, prettyPrintStderr } from "../utils/pretty-print.ts";
 import { scrubSecrets } from "../utils/secret-scrubber.ts";
 import { refreshSkillsIfChanged } from "../utils/skills-refresh.ts";
 import { detectVcsProvider } from "../vcs/index.ts";
+import { validateJsonSchema } from "../workflows/json-schema-validator.ts";
 import { interpolate } from "../workflows/template.ts";
 import { buildContextPreamble } from "./context-preamble.ts";
 import { awaitCredentials, BootMaxWaitExceededError, EX_CONFIG } from "./credential-wait.ts";
@@ -704,6 +705,56 @@ Extract the structured data from the progress updates above. Return ONLY valid J
   }
 }
 
+async function validateProviderOutputIfNeeded(
+  config: ApiConfig,
+  taskId: string,
+  providerOutput: string,
+): Promise<{ ok: true } | { ok: false; failReason: string }> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  if (config.apiKey) {
+    headers.Authorization = `Bearer ${config.apiKey}`;
+  }
+
+  try {
+    const taskRes = await fetch(`${config.apiUrl}/api/tasks/${taskId}`, { headers });
+    if (!taskRes.ok) {
+      return { ok: true };
+    }
+
+    const taskData = (await taskRes.json()) as {
+      outputSchema?: Record<string, unknown>;
+    };
+    if (!taskData.outputSchema || typeof taskData.outputSchema !== "object") {
+      return { ok: true };
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(providerOutput);
+    } catch {
+      return {
+        ok: false,
+        failReason:
+          "Structured output required by outputSchema but provider output was not valid JSON",
+      };
+    }
+
+    const validationErrors = validateJsonSchema(taskData.outputSchema, parsed);
+    if (validationErrors.length > 0) {
+      return {
+        ok: false,
+        failReason: `Structured output did not match outputSchema: ${validationErrors.join("; ")}`,
+      };
+    }
+  } catch {
+    return { ok: true };
+  }
+
+  return { ok: true };
+}
+
 export async function ensureTaskFinished(
   config: ApiConfig,
   role: string,
@@ -734,12 +785,14 @@ export async function ensureTaskFinished(
   if (status === "failed") {
     body.failureReason = failureReason || `Claude process exited with code ${exitCode}`;
   } else if (providerOutput) {
-    // Provider already supplied structured output (e.g. Devin) — use directly.
-    // NOTE: providerOutput is NOT validated against task.outputSchema here.
-    // Known gap for default-mode Devin; see runbooks/harness-providers.md
-    // ("Per-task outputSchema support"). Schema enforcement only happens on
-    // the MCP path via store-progress.
-    body.output = providerOutput;
+    const validation = await validateProviderOutputIfNeeded(config, taskId, providerOutput);
+    if (validation.ok) {
+      body.output = providerOutput;
+    } else {
+      status = "failed";
+      body.status = "failed";
+      body.failureReason = validation.failReason;
+    }
   } else {
     // Try structured output fallback if the task has an outputSchema
     const adapterType = provider ?? process.env.HARNESS_PROVIDER ?? "claude";

package/src/http/index.ts

@@ -24,6 +24,7 @@ import {
 import { startSlackApp, stopSlackApp } from "../slack";
 import { initTelemetry, telemetry } from "../telemetry";
 import { getApiKey } from "../utils/api-key";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import { initWorkflows } from "../workflows";
 import { handleActiveSessions } from "./active-sessions";
 import { handleAgentRegister, handleAgentsRest } from "./agents";
@@ -68,6 +69,7 @@ import {
   getPathSegments,
   httpServerSemconvAttributes,
   parseQueryParams,
+  safeRequestUrlForLog,
   setCorsHeaders,
 } from "./utils";
 import { handleWebhooks } from "./webhooks";
@@ -124,7 +126,9 @@ const httpServer = createHttpServer(async (req, res) => {
   const logRequest = () => {
     const elapsed = (performance.now() - startTime).toFixed(1);
     const statusEmoji = statusCode >= 400 ? "⚠️" : "✓";
-    console.log(`[HTTP] ${statusEmoji} ${req.method} ${req.url} → ${statusCode} (${elapsed}ms)`);
+    console.log(
+      `[HTTP] ${statusEmoji} ${req.method} ${safeRequestUrlForLog(req.url)} → ${statusCode} (${elapsed}ms)`,
+    );
   };
 
   // Ensure we log on response finish
@@ -132,7 +136,9 @@ const httpServer = createHttpServer(async (req, res) => {
 
   // Log errors
   res.on("error", (err) => {
-    console.error(`[HTTP] ❌ ${req.method} ${req.url} → Error: ${err.message}`);
+    console.error(
+      `[HTTP] ❌ ${req.method} ${safeRequestUrlForLog(req.url)} → Error: ${scrubSecrets(err.message)}`,
+    );
   });
 
   await withRemoteContext(req.headers as Record<string, unknown>, async () => {
@@ -257,7 +263,9 @@ const httpServer = createHttpServer(async (req, res) => {
           span.setStatus({ code: 2, message: err instanceof Error ? err.message : String(err) });
         }
         const message = err instanceof Error ? err.message : String(err);
-        console.error(`[HTTP] ❌ ${req.method} ${req.url} → ${message}`);
+        console.error(
+          `[HTTP] ❌ ${req.method} ${safeRequestUrlForLog(req.url)} → ${scrubSecrets(message)}`,
+        );
         if (!res.headersSent) {
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: message }));

package/src/http/tasks.ts

@@ -22,6 +22,7 @@ import {
   updateTaskVcs,
 } from "../be/db";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
+import { createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
 import { telemetry } from "../telemetry";
 import {
   type AgentTaskSource,
@@ -635,6 +636,22 @@ export async function handleTasks(
         filter: ({}, ctx) => ctx.deps.length > 0,
         conditions: [{ timeout_ms: 3_600_000 }], // 1 hour: task running time
       });
+
+      try {
+        const followUp = createWorkerTaskFollowUp({
+          task: result.task,
+          status: parsed.body.status,
+          output: parsed.body.output,
+          failureReason: parsed.body.failureReason,
+        });
+        if (followUp) {
+          console.log(
+            `[tasks.finish] Created follow-up task ${followUp.id.slice(0, 8)} for ${parsed.body.status} task ${parsed.params.id.slice(0, 8)}`,
+          );
+        }
+      } catch (err) {
+        console.warn(`[tasks.finish] Failed to create follow-up task: ${err}`);
+      }
     }
 
     json(res, {

package/src/http/utils.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { getActiveTaskCount } from "../be/db";
+import { scrubSecrets } from "../utils/secret-scrubber";
 
 export function setCorsHeaders(req: IncomingMessage, res: ServerResponse) {
   // Echo the request Origin (rather than emitting `*`) so credentialed fetches
@@ -46,6 +47,22 @@ export function getPathSegments(url: string): string[] {
   return path.split("/").filter(Boolean);
 }
 
+export function safeRequestUrlForLog(rawUrl: string | undefined): string {
+  if (!rawUrl) return "";
+
+  try {
+    const url = new URL(rawUrl, "http://localhost");
+    const params = Array.from(url.searchParams.keys());
+    if (params.length === 0) return url.pathname;
+
+    const redactedQuery = params.map((key) => `${key}=[REDACTED]`).join("&");
+    return `${url.pathname}?${redactedQuery}`;
+  } catch {
+    const pathOnly = rawUrl.split("?")[0] || rawUrl;
+    return scrubSecrets(pathOnly);
+  }
+}
+
 /** Add capacity info to agent response */
 export function agentWithCapacity<T extends { id: string; maxTasks?: number }>(
   agent: T,

package/src/oauth/ensure-token.ts

@@ -1,6 +1,18 @@
-import { getOAuthApp, getOAuthTokens, isTokenExpiringSoon } from "../be/db-queries/oauth";
+import {
+  acquireOAuthRefreshLock,
+  getOAuthApp,
+  getOAuthTokens,
+  isTokenExpiringSoon,
+  releaseOAuthRefreshLock,
+} from "../be/db-queries/oauth";
+import type { OAuthTokens } from "../tracker/types";
 import { type OAuthProviderConfig, refreshAccessToken } from "./wrapper";
 
+const refreshLocks = new Map<string, Promise<void>>();
+const REFRESH_LOCK_TTL_MS = 2 * 60 * 1000;
+const REFRESH_LOCK_WAIT_MS = 30 * 1000;
+const REFRESH_LOCK_POLL_MS = 250;
+
 /**
  * Build an OAuthProviderConfig from the oauth_apps table for any provider.
  */
@@ -22,6 +34,41 @@ function getOAuthConfig(provider: string): OAuthProviderConfig | null {
   };
 }
 
+async function withProviderRefreshLock<T>(provider: string, fn: () => Promise<T>): Promise<T> {
+  const previous = refreshLocks.get(provider) ?? Promise.resolve();
+  let release!: () => void;
+  const current = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const next = previous.catch(() => undefined).then(() => current);
+  refreshLocks.set(provider, next);
+
+  await previous.catch(() => undefined);
+
+  try {
+    return await fn();
+  } finally {
+    release();
+    if (refreshLocks.get(provider) === next) {
+      refreshLocks.delete(provider);
+    }
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function tokenRowChanged(current: OAuthTokens | null, observed: OAuthTokens | null): boolean {
+  if (!observed) return current !== null;
+  if (!current) return true;
+  return (
+    current.accessToken !== observed.accessToken ||
+    current.refreshToken !== observed.refreshToken ||
+    current.expiresAt !== observed.expiresAt
+  );
+}
+
 /**
  * Ensure a valid OAuth token exists for the given provider.
  * If the token is expiring soon, attempt to refresh it.
@@ -57,16 +104,55 @@ export async function ensureToken(provider: string, bufferMs?: number): Promise<
  */
 export async function ensureTokenOrThrow(provider: string, bufferMs?: number): Promise<void> {
   if (!isTokenExpiringSoon(provider, bufferMs)) return;
+  const observedTokens = getOAuthTokens(provider);
 
-  const config = getOAuthConfig(provider);
-  const tokens = getOAuthTokens(provider);
-  if (!config || !tokens?.refreshToken) {
-    console.warn(
-      `[OAuth] ${provider} token expiring but cannot refresh (missing config or refresh token)`,
-    );
-    return;
-  }
+  await withProviderRefreshLock(provider, async () => {
+    const waitStartedAt = Date.now();
+
+    while (isTokenExpiringSoon(provider, bufferMs)) {
+      const tokens = getOAuthTokens(provider);
+      if (tokenRowChanged(tokens, observedTokens)) return;
+
+      const config = getOAuthConfig(provider);
+      if (!config || !tokens?.refreshToken) {
+        console.warn(
+          `[OAuth] ${provider} token expiring but cannot refresh (missing config or refresh token)`,
+        );
+        return;
+      }
+
+      const lockOwner = acquireOAuthRefreshLock(provider, REFRESH_LOCK_TTL_MS);
+      if (!lockOwner) {
+        if (Date.now() - waitStartedAt > REFRESH_LOCK_WAIT_MS) {
+          throw new Error(`Timed out waiting for ${provider} OAuth token refresh lock`);
+        }
+        await sleep(REFRESH_LOCK_POLL_MS);
+        continue;
+      }
+
+      try {
+        const lockedTokens = getOAuthTokens(provider);
+        if (
+          !isTokenExpiringSoon(provider, bufferMs) ||
+          tokenRowChanged(lockedTokens, observedTokens)
+        ) {
+          return;
+        }
+
+        const lockedConfig = getOAuthConfig(provider);
+        if (!lockedConfig || !lockedTokens?.refreshToken) {
+          console.warn(
+            `[OAuth] ${provider} token expiring but cannot refresh (missing config or refresh token)`,
+          );
+          return;
+        }
 
-  await refreshAccessToken(config, tokens.refreshToken);
-  console.log(`[OAuth] ${provider} token refreshed successfully`);
+        await refreshAccessToken(lockedConfig, lockedTokens.refreshToken);
+        console.log(`[OAuth] ${provider} token refreshed successfully`);
+        return;
+      } finally {
+        releaseOAuthRefreshLock(provider, lockOwner);
+      }
+    }
+  });
 }

package/src/providers/pi-mono-adapter.ts

@@ -316,6 +316,26 @@ function cleanupAgentsMdSymlink(cwd: string): void {
   }
 }
 
+function extractTextContent(content: unknown): string {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter(
+      (c): c is { type?: string; text?: string } =>
+        typeof c === "object" && c !== null && (c as { type?: string }).type === "text",
+    )
+    .map((c) => c.text || "")
+    .join("")
+    .trim();
+}
+
+export function extractPiAssistantText(message: unknown): string {
+  if (!message || typeof message !== "object") return "";
+  const msg = message as { role?: string; content?: unknown };
+  if (msg.role !== "assistant") return "";
+  return extractTextContent(msg.content);
+}
+
 export class PiMonoSession implements ProviderSession {
   private listeners: Array<(event: ProviderEvent) => void> = [];
   private eventQueue: ProviderEvent[] = [];
@@ -327,6 +347,8 @@ export class PiMonoSession implements ProviderSession {
   private logFileHandle: ReturnType<ReturnType<typeof Bun.file>["writer"]>;
   /** Track last emitted message text to avoid duplicates across turns */
   private lastEmittedMessage = "";
+  /** Last assistant text surfaced by pi-mono; used as runner fallback output. */
+  private lastAssistantText = "";
   /** Phase 7: wallclock start so we can populate `durationMs` on the cost row. */
   private sessionStartedAt: number = Date.now();
   /**
@@ -391,31 +413,27 @@ export class PiMonoSession implements ProviderSession {
   private handleAgentEvent(event: AgentSessionEvent): void {
     switch (event.type) {
       case "message_end": {
-        // Extract text from the final message (skip duplicates across turns)
-        const msg = event.message;
-        if (msg && "content" in msg) {
-          const text = Array.isArray(msg.content)
-            ? msg.content
-                .filter((c: unknown) => (c as { type: string }).type === "text")
-                .map((c: unknown) => (c as { text?: string }).text || "")
-                .join("")
-                .trim()
-            : String(msg.content || "").trim();
-          if (text && text !== this.lastEmittedMessage) {
-            const model = this.reportedModel();
-            this.emit({
-              type: "raw_log",
-              content: JSON.stringify({
-                type: "assistant",
-                message: {
-                  role: "assistant",
-                  content: [{ type: "text", text }],
-                  model,
-                },
-              }),
-            });
-            this.lastEmittedMessage = text;
-          }
+        // Pi emits message_end for user, assistant, and tool-result messages.
+        // Only assistant text should be printed or used as fallback output.
+        const text = extractPiAssistantText(event.message);
+        if (text) {
+          this.lastAssistantText = text;
+        }
+        if (text && text !== this.lastEmittedMessage) {
+          const model = this.reportedModel();
+          this.emit({
+            type: "raw_log",
+            content: JSON.stringify({
+              type: "assistant",
+              message: {
+                role: "assistant",
+                content: [{ type: "text", text }],
+                model,
+              },
+            }),
+          });
+          this.emit({ type: "message", role: "assistant", content: text });
+          this.lastEmittedMessage = text;
         }
         // Emit context_usage for dashboard tracking.
         // Phase 7: derive `outputTokens` from `SessionStats` delta (pi-ai's
@@ -522,6 +540,7 @@ export class PiMonoSession implements ProviderSession {
         exitCode: 0,
         sessionId: this._sessionId,
         cost,
+        output: this.lastAssistantText || undefined,
         isError: false,
       };
     } catch (err) {

package/src/server.ts

@@ -43,6 +43,7 @@ import { registerMemoryGetTool } from "./tools/memory-get";
 import { registerMemoryRateTool } from "./tools/memory-rate";
 import { registerMemorySearchTool } from "./tools/memory-search";
 import { registerMyAgentInfoTool } from "./tools/my-agent-info";
+import { registerGetOauthAccessTokenTool } from "./tools/oauth-access-token";
 import { registerPollTaskTool } from "./tools/poll-task";
 import { registerPostMessageTool } from "./tools/post-message";
 // Prompt template tools
@@ -199,6 +200,7 @@ export function createServer() {
 
   // Debug tools - always registered (self-guards with lead check)
   registerDbQueryTool(server);
+  registerGetOauthAccessTokenTool(server);
 
   // Swarm config tools - always registered (config management is fundamental)
   registerSetConfigTool(server);

package/src/tasks/worker-follow-up.ts

@@ -0,0 +1,82 @@
+import { createTaskExtended, getAgentById, getLeadAgent, getTaskAttachments } from "../be/db";
+import { resolveTemplate } from "../prompts/resolver";
+import type { AgentTask, TaskAttachment } from "../types";
+// Side-effect import: registers task lifecycle templates in the in-memory registry.
+import "../tools/templates";
+
+function attachmentPointer(a: TaskAttachment): string {
+  switch (a.kind) {
+    case "url":
+      return a.url ?? "";
+    case "page":
+      return `page:${a.pageId ?? ""}`;
+    case "agent-fs":
+      return `agent-fs:${a.path ?? ""}`;
+    case "shared-fs":
+      return `shared-fs:${a.path ?? ""}`;
+  }
+}
+
+function formatAttachmentsBlock(attachments: TaskAttachment[]): string {
+  if (attachments.length === 0) return "";
+  const lines = attachments.map((a) => {
+    const tag = a.isPrimary ? "[primary] " : "";
+    const intent = a.intent ? ` (intent: ${a.intent})` : "";
+    return `- ${tag}${a.name} - ${attachmentPointer(a)}${intent}`;
+  });
+  return `\n\nAttachments (${attachments.length}):\n${lines.join("\n")}`;
+}
+
+export function createWorkerTaskFollowUp(args: {
+  task: AgentTask;
+  status: "completed" | "failed";
+  output?: string;
+  failureReason?: string;
+}): AgentTask | null {
+  const { task, status, output, failureReason } = args;
+
+  if (task.workflowRunId) return null;
+
+  const taskAgent = getAgentById(task.agentId ?? "");
+  if (!taskAgent || taskAgent.isLead) return null;
+
+  const leadAgent = getLeadAgent();
+  if (!leadAgent) return null;
+
+  const agentName = taskAgent.name || task.agentId?.slice(0, 8) || "Unknown";
+  const taskDesc = task.task.slice(0, 200);
+
+  let followUpDescription: string;
+  if (status === "completed") {
+    const attachmentsBlock = formatAttachmentsBlock(getTaskAttachments(task.id));
+    const outputSummary = output
+      ? `${output.slice(0, 500)}${output.length > 500 ? "..." : ""}${attachmentsBlock}`
+      : `(no output)${attachmentsBlock}`;
+    const completedResult = resolveTemplate("task.worker.completed", {
+      agent_name: agentName,
+      task_desc: taskDesc,
+      output_summary: outputSummary,
+      task_id: task.id,
+    });
+    followUpDescription = completedResult.text;
+  } else {
+    const reason = failureReason || "(no reason given)";
+    const failedResult = resolveTemplate("task.worker.failed", {
+      agent_name: agentName,
+      task_desc: taskDesc,
+      failure_reason: reason,
+      task_id: task.id,
+    });
+    followUpDescription = failedResult.text;
+  }
+
+  return createTaskExtended(followUpDescription, {
+    agentId: leadAgent.id,
+    source: "system",
+    taskType: "follow-up",
+    parentTaskId: task.id,
+    slackChannelId: task.slackChannelId,
+    slackThreadTs: task.slackThreadTs,
+    slackUserId: task.slackUserId,
+  });
+}

package/src/tests/agents-list-model-display.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, test } from "bun:test";
-import { getAgentModelDisplay } from "../../ui/src/lib/agents-list-model-display";
+import {
+  getAgentModelDisplay,
+  getAgentModelPresentation,
+} from "../../ui/src/lib/agents-list-model-display";
 
 describe("agents list model display", () => {
   test("shows configured and last-used models when they diverge", () => {
@@ -30,4 +33,13 @@ describe("agents list model display", () => {
     expect(display.primary).toBe("claude-opus-4-7");
     expect(display.diverged).toBe(false);
   });
+
+  test("presents known provider-prefixed model ids as readable labels", () => {
+    expect(getAgentModelPresentation("openrouter/deepseek/deepseek-v4-flash")).toEqual({
+      raw: "openrouter/deepseek/deepseek-v4-flash",
+      label: "DeepSeek V4 Flash",
+      provider: "OpenRouter",
+      providerId: "openrouter",
+    });
+  });
 });