@desplega.ai/agent-swarm 1.93.0 → 1.94.0

package/src/slack/responses.ts

@@ -15,6 +15,20 @@ import {
 // Re-export for backward compatibility
 export { markdownToSlack } from "./blocks";
 
+export type SlackUpdateResult = "ok" | "not_found" | "failed";
+
+function classifySlackUpdateError(error: unknown): SlackUpdateResult {
+  const errorCode = (error as { data?: { error?: string } } | undefined)?.data?.error;
+  if (
+    errorCode === "message_not_found" ||
+    errorCode === "channel_not_found" ||
+    errorCode === "thread_not_found"
+  ) {
+    return "not_found";
+  }
+  return "failed";
+}
+
 const isDev = process.env.ENV === "development";
 
 /**
@@ -140,12 +154,12 @@ export async function updateProgressInPlace(
   task: AgentTask,
   progress: string,
   messageTs: string,
-): Promise<boolean> {
+): Promise<SlackUpdateResult> {
   const app = getSlackApp();
-  if (!app || !task.slackChannelId || !task.agentId) return false;
+  if (!app || !task.slackChannelId || !task.agentId) return "failed";
 
   const agent = getAgentById(task.agentId);
-  if (!agent) return false;
+  if (!agent) return "failed";
 
   const blocks = buildProgressBlocks({ agentName: agent.name, taskId: task.id, progress });
 
@@ -157,10 +171,17 @@ export async function updateProgressInPlace(
       // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
       blocks: blocks as any,
     });
-    return true;
+    return "ok";
   } catch (error) {
-    console.error(`[Slack] Failed to update progress in-place:`, error);
-    return false;
+    const result = classifySlackUpdateError(error);
+    if (result === "not_found") {
+      console.warn(
+        `[Slack] Progress message missing for task ${task.id} ts=${messageTs}; will repost`,
+      );
+    } else {
+      console.error(`[Slack] Failed to update progress in-place:`, error);
+    }
+    return result;
   }
 }
 
@@ -233,9 +254,9 @@ export async function updateTreeMessage(
   messageTs: string,
   blocks: unknown[],
   fallbackText: string,
-): Promise<boolean> {
+): Promise<SlackUpdateResult> {
   const app = getSlackApp();
-  if (!app) return false;
+  if (!app) return "failed";
 
   try {
     await app.client.chat.update({
@@ -245,10 +266,17 @@ export async function updateTreeMessage(
       // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
       blocks: blocks as any,
     });
-    return true;
+    return "ok";
   } catch (error) {
-    console.error(`[Slack] Failed to update tree message:`, error);
-    return false;
+    const result = classifySlackUpdateError(error);
+    if (result === "not_found") {
+      console.warn(
+        `[Slack] Tree message missing for channel=${channelId} ts=${messageTs}; will repost`,
+      );
+    } else {
+      console.error(`[Slack] Failed to update tree message:`, error);
+    }
+    return result;
   }
 }
 

package/src/slack/watcher.ts

@@ -5,6 +5,7 @@ import {
   getInProgressSlackTasks,
   getTaskAttachments,
   getTaskById,
+  setSlackMessageTracking,
 } from "../be/db";
 import type { AgentTask } from "../types";
 import { getSlackApp } from "./app";
@@ -76,6 +77,15 @@ export function registerTreeMessage(
   // Also register in legacy flat map so existing watcher processing still works
   taskMessages.set(taskId, { channelId, threadTs, messageTs });
 
+  try {
+    setSlackMessageTracking(taskId, {
+      slackProgressMessageTs: messageTs,
+      slackTreeRootMessageTs: messageTs,
+    });
+  } catch (error) {
+    console.error(`[Slack] Failed to persist message tracking for task ${taskId}:`, error);
+  }
+
   console.log(`[Slack] Registered task ${taskId.slice(0, 8)} in tree message ${messageTs}`);
 }
 
@@ -193,6 +203,12 @@ export function _getTreeMessages(): Map<string, TreeMessageState> {
 export function _getTaskToTree(): Map<string, string> {
   return taskToTree;
 }
+export function _getTaskMessages(): Map<
+  string,
+  { channelId: string; threadTs: string; messageTs: string }
+> {
+  return taskMessages;
+}
 export function _getLastRenderedTree(): Map<string, string> {
   return lastRenderedTree;
 }
@@ -306,13 +322,35 @@ export async function processTreeMessages(): Promise<void> {
       : `Tasks in progress: ${rootNames}`;
 
     // Update the Slack message
-    const success = await updateTreeMessage(tree.channelId, messageTs, blocks, fallbackText);
+    const result = await updateTreeMessage(tree.channelId, messageTs, blocks, fallbackText);
+    const success = result === "ok";
     if (success) {
       lastRenderedTree.set(messageTs, serialized);
       treeLastUpdateTime.set(messageTs, now);
       console.log(
         `[Slack] Updated tree message ${messageTs} (${nodes.length} root(s), terminal=${fullyTerminal})`,
       );
+    } else if (result === "not_found") {
+      const taskIds = Array.from(tree.rootTaskIds);
+      for (const taskId of taskIds) {
+        taskToTree.delete(taskId);
+        taskMessages.delete(taskId);
+        try {
+          setSlackMessageTracking(taskId, {
+            slackProgressMessageTs: null,
+            slackTreeRootMessageTs: null,
+          });
+        } catch (error) {
+          console.error(`[Slack] Failed to clear stale message tracking for ${taskId}:`, error);
+        }
+      }
+      treeMessages.delete(messageTs);
+      lastRenderedTree.delete(messageTs);
+      treeLastUpdateTime.delete(messageTs);
+      console.warn(
+        `[Slack] Dropped stale tree ${messageTs} (${taskIds.length} task(s)); will repost on next tick`,
+      );
+      continue;
     }
 
     // DM channels: set assistant status in parallel for typing indicator UX
@@ -437,6 +475,50 @@ export function startTaskWatcher(intervalMs = 3000): void {
   }
   console.log(`[Slack] Initialized with ${existingCompleted.length} existing completed tasks`);
 
+  let hydratedTrees = 0;
+  let hydratedFlat = 0;
+  for (const task of getInProgressSlackTasks()) {
+    if (!task.slackChannelId || !task.slackThreadTs) continue;
+
+    const treeTs = task.slackTreeRootMessageTs;
+    const progressTs = task.slackProgressMessageTs;
+
+    if (treeTs) {
+      let tree = treeMessages.get(treeTs);
+      if (!tree) {
+        tree = {
+          channelId: task.slackChannelId,
+          threadTs: task.slackThreadTs,
+          messageTs: treeTs,
+          rootTaskIds: new Set(),
+        };
+        treeMessages.set(treeTs, tree);
+      }
+      tree.rootTaskIds.add(task.id);
+      taskToTree.set(task.id, treeTs);
+      taskMessages.set(task.id, {
+        channelId: task.slackChannelId,
+        threadTs: task.slackThreadTs,
+        messageTs: treeTs,
+      });
+      if (task.progress) sentProgress.set(task.id, task.progress);
+      hydratedTrees++;
+    } else if (progressTs) {
+      taskMessages.set(task.id, {
+        channelId: task.slackChannelId,
+        threadTs: task.slackThreadTs,
+        messageTs: progressTs,
+      });
+      if (task.progress) sentProgress.set(task.id, task.progress);
+      hydratedFlat++;
+    }
+  }
+  if (hydratedTrees > 0 || hydratedFlat > 0) {
+    console.log(
+      `[Slack] Hydrated ${hydratedTrees} tree task(s) and ${hydratedFlat} flat task(s) from DB`,
+    );
+  }
+
   watcherInterval = setInterval(async () => {
     // Prevent overlapping processing cycles
     if (isProcessing || !getSlackApp()) return;
@@ -515,8 +597,20 @@ export function startTaskWatcher(intervalMs = 3000): void {
           sentProgress.set(task.id, "__in_progress__");
           lastSendTime.set(progressKey, now);
           try {
-            await updateProgressInPlace(task, "Starting...", tracked.messageTs);
-            console.log(`[Slack] Updated to in-progress for task ${task.id.slice(0, 8)}`);
+            const result = await updateProgressInPlace(task, "Starting...", tracked.messageTs);
+            if (result === "not_found") {
+              taskMessages.delete(task.id);
+              sentProgress.delete(task.id);
+              setSlackMessageTracking(task.id, {
+                slackProgressMessageTs: null,
+                slackTreeRootMessageTs: null,
+              });
+            } else if (result === "ok") {
+              console.log(`[Slack] Updated to in-progress for task ${task.id.slice(0, 8)}`);
+            } else {
+              sentProgress.delete(task.id);
+              lastSendTime.delete(progressKey);
+            }
           } catch (error) {
             sentProgress.delete(task.id);
             lastSendTime.delete(progressKey);
@@ -535,23 +629,42 @@ export function startTaskWatcher(intervalMs = 3000): void {
           sentProgress.set(task.id, task.progress);
           lastSendTime.set(progressKey, now);
           try {
+            let postedTs: string | undefined;
             if (tracked) {
               // Update the existing message in-place via chat.update
-              await updateProgressInPlace(task, task.progress, tracked.messageTs);
-              console.log(`[Slack] Updated progress in-place for task ${task.id.slice(0, 8)}`);
+              const result = await updateProgressInPlace(task, task.progress, tracked.messageTs);
+              if (result === "ok") {
+                console.log(`[Slack] Updated progress in-place for task ${task.id.slice(0, 8)}`);
+              } else if (result === "not_found") {
+                taskMessages.delete(task.id);
+                postedTs = await sendProgressUpdate(task, task.progress);
+                if (postedTs && task.slackChannelId && task.slackThreadTs) {
+                  taskMessages.set(task.id, {
+                    channelId: task.slackChannelId,
+                    threadTs: task.slackThreadTs,
+                    messageTs: postedTs,
+                  });
+                }
+              } else {
+                sentProgress.delete(task.id);
+                lastSendTime.delete(progressKey);
+              }
             } else {
               // No tracked message (e.g., multi-task assignment or server restart)
               // Post a new progress message and track its ts
-              const messageTs = await sendProgressUpdate(task, task.progress);
-              if (messageTs && task.slackChannelId && task.slackThreadTs) {
+              postedTs = await sendProgressUpdate(task, task.progress);
+              if (postedTs && task.slackChannelId && task.slackThreadTs) {
                 taskMessages.set(task.id, {
                   channelId: task.slackChannelId,
                   threadTs: task.slackThreadTs,
-                  messageTs,
+                  messageTs: postedTs,
                 });
               }
               console.log(`[Slack] Sent initial progress for task ${task.id.slice(0, 8)}`);
             }
+            if (postedTs) {
+              setSlackMessageTracking(task.id, { slackProgressMessageTs: postedTs });
+            }
           } catch (error) {
             // If send fails, clear markers so we can retry
             sentProgress.delete(task.id);

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

@@ -42,4 +42,17 @@ describe("agents list model display", () => {
       providerId: "openrouter",
     });
   });
+
+  test("presents latest Anthropic direct model ids as readable labels", () => {
+    expect(getAgentModelPresentation("claude-fable-5")).toMatchObject({
+      label: "Claude Fable 5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
+    expect(getAgentModelPresentation("claude-mythos-5")).toMatchObject({
+      label: "Claude Mythos 5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
+  });
 });

package/src/tests/aws-error-classifier.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Unit tests for `classifyAwsSdkError` in `src/utils/aws-error-classifier.ts`.
+ *
+ * Exercises all four error categories and the no-match path.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { classifyAwsSdkError } from "../utils/aws-error-classifier";
+
+describe("classifyAwsSdkError — aws-auth", () => {
+  test("ExpiredTokenException", () => {
+    const r = classifyAwsSdkError(
+      "ExpiredTokenException: The security token included in the request is expired",
+    );
+    expect(r).not.toBeNull();
+    expect(r!.category).toBe("aws-auth");
+    expect(r!.message).toContain("aws sso login");
+  });
+
+  test("ExpiredToken (without Exception suffix)", () => {
+    const r = classifyAwsSdkError("ExpiredToken: token expired");
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("CredentialsProviderError", () => {
+    const r = classifyAwsSdkError("CredentialsProviderError: Could not load credentials");
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("Unable to locate credentials", () => {
+    const r = classifyAwsSdkError(
+      'Unable to locate credentials. You can configure credentials by running "aws configure".',
+    );
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("security token ... expired (lower-case)", () => {
+    const r = classifyAwsSdkError("The security token included in the request is expired");
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("InvalidSignatureException", () => {
+    const r = classifyAwsSdkError(
+      "InvalidSignatureException: The request signature we calculated does not match the signature you provided",
+    );
+    expect(r?.category).toBe("aws-auth");
+  });
+
+  test("UnrecognizedClientException", () => {
+    const r = classifyAwsSdkError(
+      "UnrecognizedClientException: The security token included in the request is invalid",
+    );
+    expect(r?.category).toBe("aws-auth");
+  });
+});
+
+describe("classifyAwsSdkError — aws-throttle", () => {
+  test("ThrottlingException", () => {
+    const r = classifyAwsSdkError("ThrottlingException: Rate exceeded");
+    expect(r?.category).toBe("aws-throttle");
+    expect(r!.message).toContain("quota");
+  });
+
+  test("TooManyRequestsException", () => {
+    const r = classifyAwsSdkError("TooManyRequestsException: Too many requests");
+    expect(r?.category).toBe("aws-throttle");
+  });
+
+  test("ServiceQuotaExceededException", () => {
+    const r = classifyAwsSdkError(
+      "ServiceQuotaExceededException: You have exceeded your request quota for this service",
+    );
+    expect(r?.category).toBe("aws-throttle");
+  });
+
+  test("Rate exceeded (standalone phrase)", () => {
+    const r = classifyAwsSdkError("Rate exceeded. Reduce your request rate.");
+    expect(r?.category).toBe("aws-throttle");
+  });
+});
+
+describe("classifyAwsSdkError — aws-access", () => {
+  test("AccessDeniedException with bedrock:InvokeModel", () => {
+    const r = classifyAwsSdkError(
+      "AccessDeniedException: User: arn:aws:iam::123:user/dev is not authorized to perform: bedrock:InvokeModel on resource: arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-v2",
+    );
+    expect(r?.category).toBe("aws-access");
+    expect(r!.message).toContain("bedrock:InvokeModel");
+  });
+
+  test("not authorized to perform (phrase match)", () => {
+    const r = classifyAwsSdkError("User is not authorized to perform: bedrock:InvokeModel");
+    expect(r?.category).toBe("aws-access");
+  });
+});
+
+describe("classifyAwsSdkError — aws-model", () => {
+  test("ValidationException", () => {
+    const r = classifyAwsSdkError(
+      "ValidationException: Invocation of model ID anthropic.claude-v99 with on-demand throughput isn't supported",
+    );
+    expect(r?.category).toBe("aws-model");
+    expect(r!.message).toContain("MODEL_OVERRIDE");
+  });
+
+  test("ResourceNotFoundException", () => {
+    const r = classifyAwsSdkError("ResourceNotFoundException: Could not find model");
+    expect(r?.category).toBe("aws-model");
+  });
+
+  test("ModelTimeoutException", () => {
+    const r = classifyAwsSdkError(
+      "ModelTimeoutException: The model timed out processing your request",
+    );
+    expect(r?.category).toBe("aws-model");
+  });
+
+  test("ModelNotReadyException", () => {
+    const r = classifyAwsSdkError("ModelNotReadyException: The model is not ready for inference");
+    expect(r?.category).toBe("aws-model");
+  });
+});
+
+describe("classifyAwsSdkError — priority ordering", () => {
+  test("aws-auth wins over aws-model when both match (ExpiredToken + ValidationException)", () => {
+    // Should not happen in practice, but priority must be deterministic
+    const r = classifyAwsSdkError("ExpiredTokenException and also ValidationException");
+    expect(r?.category).toBe("aws-auth");
+  });
+});
+
+describe("classifyAwsSdkError — no-match", () => {
+  test("returns null for empty string", () => {
+    expect(classifyAwsSdkError("")).toBeNull();
+  });
+
+  test("returns null for unrelated error", () => {
+    expect(classifyAwsSdkError("TypeError: Cannot read property 'foo' of undefined")).toBeNull();
+  });
+
+  test("returns null for generic network error", () => {
+    expect(classifyAwsSdkError("ECONNREFUSED 127.0.0.1:3013")).toBeNull();
+  });
+
+  test("returns null for Claude API error (not AWS)", () => {
+    expect(classifyAwsSdkError("401 Unauthorized: Invalid API key")).toBeNull();
+  });
+});

package/src/tests/claude-managed-adapter.test.ts

@@ -794,6 +794,18 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
   });
 
   test("CLAUDE_MANAGED_MODEL_PRICING covers sonnet, opus, haiku at minimum", () => {
+    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-fable-5"]).toEqual({
+      inputPerMillion: 10.0,
+      outputPerMillion: 50.0,
+      cacheReadPerMillion: 1.0,
+      cacheWritePerMillion: 12.5,
+    });
+    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-mythos-5"]).toEqual({
+      inputPerMillion: 10.0,
+      outputPerMillion: 50.0,
+      cacheReadPerMillion: 1.0,
+      cacheWritePerMillion: 12.5,
+    });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-4-6"]).toBeDefined();
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-4-7"]).toBeDefined();
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-haiku-4-5"]).toBeDefined();

package/src/tests/context-window.test.ts

@@ -8,6 +8,13 @@ import {
 } from "../utils/context-window";
 
 describe("getContextWindowSize", () => {
+  test("returns 1M for fable and mythos models", () => {
+    expect(getContextWindowSize("claude-fable-5")).toBe(1_000_000);
+    expect(getContextWindowSize("claude-mythos-5")).toBe(1_000_000);
+    expect(getContextWindowSize("fable")).toBe(1_000_000);
+    expect(getContextWindowSize("mythos")).toBe(1_000_000);
+  });
+
   test("returns 1M for opus models", () => {
     expect(getContextWindowSize("claude-opus-4-8")).toBe(1_000_000);
     expect(getContextWindowSize("claude-opus-4-7")).toBe(1_000_000);

package/src/tests/http-api-integration.test.ts

@@ -1012,6 +1012,25 @@ describe("Schedule CRUD", () => {
     expect(body.task.id).toBeDefined();
   });
 
+  test("POST /api/schedules/:id/run — propagates modelTier to the created task", async () => {
+    const { body: created } = await post("/api/schedules", {
+      body: {
+        name: "model-tier-manual-run",
+        taskTemplate: "Run model tier integration test",
+        cronExpression: "0 * * * *",
+        modelTier: "smart",
+      },
+    });
+
+    const { status, body } = await post(`/api/schedules/${created.id}/run`);
+    expect(status).toBe(200);
+    expect(body.task).toBeDefined();
+    expect(body.task.model).toBeUndefined();
+    expect(body.task.modelTier).toBe("smart");
+
+    await del(`/api/schedules/${created.id}`);
+  });
+
   test("POST /api/schedules/:id/run — disabled schedule returns 400", async () => {
     // Disable the schedule first
     await put(`/api/schedules/${scheduleId}`, {

package/src/tests/metrics-http.test.ts

@@ -76,7 +76,60 @@ describe("Metrics HTTP API", () => {
     const body = (await res.json()) as { metrics: Metric[]; total: number };
     expect(body.total).toBeGreaterThanOrEqual(1);
     const starter = body.metrics.find((metric) => metric.slug === "swarm-operations-overview");
-    expect(starter?.definition.widgets.map((widget) => widget.viz.type)).toContain("multi-line");
+    expect(starter?.definition.layout?.columns).toBe(3);
+    expect(starter?.definition.widgets.map((widget) => widget.id)).toEqual([
+      "tasks-created-per-day",
+      "usage-by-user",
+      "usage-by-model",
+      "avg-cost-per-task-by-model",
+      "avg-task-time-by-model",
+      "cost-per-minute-by-model",
+      "cost-per-minute-by-agent",
+      "agent-performance",
+      "task-outcomes-by-day",
+      "recent-task-outcomes",
+    ]);
+    expect(
+      starter?.definition.variables?.find((variable) => variable.key === "userFilter"),
+    ).toMatchObject({
+      type: "select",
+      defaultValue: "all",
+      optionsQuery: { valueKey: "id", labelKey: "label" },
+    });
+    expect(
+      starter?.definition.variables?.find((variable) => variable.key === "agentFilter"),
+    ).toMatchObject({
+      type: "select",
+      defaultValue: "all",
+      optionsQuery: { valueKey: "id", labelKey: "label" },
+    });
+
+    const run = await fetch(`${BASE}/api/metrics/definitions/${starter!.id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: {} }),
+    });
+    expect(run.status).toBe(200);
+    const runBody = (await run.json()) as MetricRunResponse & {
+      metric: Metric;
+      variables: Record<string, string>;
+    };
+    expect(runBody.variables.userFilter).toBe("all");
+    expect(runBody.variables.agentFilter).toBe("all");
+    expect(
+      runBody.metric.definition.variables?.find((variable) => variable.key === "userFilter")
+        ?.options?.[0],
+    ).toEqual({
+      label: "All requesters",
+      value: "all",
+    });
+    expect(
+      runBody.metric.definition.variables?.find((variable) => variable.key === "agentFilter")
+        ?.options?.[0],
+    ).toEqual({
+      label: "All agents",
+      value: "all",
+    });
   });
 
   test("create, run, update snapshots prior definition", async () => {
@@ -221,8 +274,79 @@ describe("Metrics HTTP API", () => {
     expect(runBody.widgets[0]?.result.rows[0]).toHaveProperty("count");
   });
 
+  test("run resolves dynamic select variable options from read-only SQL", async () => {
+    const created = await fetch(`${BASE}/api/metrics/definitions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "dynamic-variable-options",
+        title: "Dynamic Variable Options",
+        definition: {
+          version: 1,
+          variables: [
+            {
+              key: "agent",
+              label: "Agent",
+              type: "select",
+              optionsQuery: {
+                sql: "SELECT 'agent-a' AS id, 'Agent A' AS name UNION ALL SELECT 'agent-b' AS id, 'Agent B' AS name",
+                valueKey: "id",
+                labelKey: "name",
+              },
+            },
+          ],
+          widgets: [
+            {
+              id: "selected-agent",
+              title: "Selected agent",
+              query: {
+                sql: "SELECT ? AS agent",
+                params: ["{{agent}}"],
+                maxRows: 10,
+              },
+              viz: { type: "table", columns: [{ key: "agent", label: "Agent" }] },
+            },
+          ],
+        },
+      }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string; version: number };
+
+    const run = await fetch(`${BASE}/api/metrics/definitions/${id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: { agent: "agent-b" } }),
+    });
+    expect(run.status).toBe(200);
+    const runBody = (await run.json()) as MetricRunResponse & {
+      metric: Metric;
+      variables: Record<string, string>;
+    };
+    expect(runBody.variables.agent).toBe("agent-b");
+    expect(runBody.metric.definition.variables?.[0]?.options).toEqual([
+      { label: "Agent A", value: "agent-a" },
+      { label: "Agent B", value: "agent-b" },
+    ]);
+    expect(runBody.widgets[0]?.result.rows[0]).toEqual({ agent: "agent-b" });
+
+    const defaultedRun = await fetch(`${BASE}/api/metrics/definitions/${id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: {} }),
+    });
+    expect(defaultedRun.status).toBe(200);
+    const defaultedBody = (await defaultedRun.json()) as { variables: Record<string, string> };
+    expect(defaultedBody.variables.agent).toBe("agent-a");
+  });
+
   test("saved metric SQL rejects writes and multiple statements", async () => {
-    for (const sql of ["DELETE FROM agent_tasks", "SELECT 1; SELECT 2"]) {
+    for (const [sql, target] of [
+      ["DELETE FROM agent_tasks", "widget"],
+      ["SELECT 1; SELECT 2", "widget"],
+      ["DELETE FROM agents", "variable"],
+      ["SELECT 1; SELECT 2", "variable"],
+    ] as const) {
       const res = await fetch(`${BASE}/api/metrics/definitions`, {
         method: "POST",
         headers,
@@ -230,11 +354,21 @@ describe("Metrics HTTP API", () => {
           title: "Bad Metric",
           definition: {
             version: 1,
+            variables:
+              target === "variable"
+                ? [
+                    {
+                      key: "agent",
+                      type: "select",
+                      optionsQuery: { sql, valueKey: "id" },
+                    },
+                  ]
+                : undefined,
             widgets: [
               {
                 id: "bad",
                 title: "Bad",
-                query: { sql },
+                query: { sql: target === "widget" ? sql : "SELECT 1 AS x" },
                 viz: { type: "stat", value: "x" },
               },
             ],