@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/src/http/models-catalog.ts

@@ -1,21 +1,48 @@
 // Live model catalog for the UI model picker.
 //
-// Serves the slim in-memory projection of the models.dev payload maintained
-// by the pricing-refresh loop (`src/be/models-catalog.ts`). Read-only: the
-// catalog is refreshed server-side (boot + every 12h); the UI polls this
-// endpoint instead of relying on the build-time snapshot bundled into the SPA.
+// GET serves the slim projection of the persistent `model_catalog` table
+// merged with `model_catalog_overlay` (src/be/model-catalog-store.ts). The
+// catalog refreshes server-side (boot + every 12h); POST .../refresh forces a
+// refresh and PUT/DELETE .../overlay manage hand-verified overlay rows.
+// See runbooks/model-catalog.md.
 
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
-import { getModelsCatalog } from "../be/models-catalog";
+import { getAgentById } from "../be/db";
+import {
+  agentRanModel,
+  getAgentHarnessCliVersion,
+  listHarnessModelSupport,
+  recordHarnessModelSupport,
+} from "../be/harness-model-support";
+import {
+  deleteModelCatalogOverlay,
+  loadModelsCatalog,
+  upsertModelCatalogOverlay,
+} from "../be/model-catalog-store";
+import { previewModelTiers } from "../be/model-tier-resolution";
+import { requestModelCatalogRefresh } from "../be/pricing-refresh";
+import { can, type RbacPrincipal } from "../rbac";
+import { MODEL_TIERS, ProviderNameSchema } from "../types";
+import { isUnknownModelError } from "../utils/harness-model-error";
+import { getRequestAuth } from "../utils/request-auth-context";
 import { route } from "./route-def";
-import { json } from "./utils";
+import { jsonError } from "./utils";
 
 const CatalogModelSchema = z.object({
   id: z.string(),
   name: z.string().optional(),
-  cost: z.object({ input: z.number().optional(), output: z.number().optional() }).optional(),
+  cost: z
+    .object({
+      input: z.number().optional(),
+      output: z.number().optional(),
+      cache_read: z.number().optional(),
+      cache_write: z.number().optional(),
+    })
+    .optional(),
   limit: z.object({ context: z.number().optional() }).optional(),
+  release_date: z.string().optional(),
+  status: z.string().optional(),
   reasoning: z.boolean().optional(),
   reasoning_options: z
     .array(z.object({ type: z.string(), values: z.array(z.string()).optional() }))
@@ -28,6 +55,61 @@ const CatalogProviderSchema = z.object({
   models: z.record(z.string(), CatalogModelSchema),
 });
 
+const ReasoningOptionSchema = z.object({
+  type: z.string(),
+  values: z.array(z.string()).optional(),
+});
+
+const OverlayPricingSchema = z.object({
+  input: z.number().nonnegative().optional(),
+  output: z.number().nonnegative().optional(),
+  cache_read: z.number().nonnegative().optional(),
+  cache_write: z.number().nonnegative().optional(),
+});
+
+export const ModelCatalogRefreshResultSchema = z.object({
+  status: z.enum(["updated", "not-modified", "skipped-fresh", "skipped-cooldown", "error"]),
+  models: z.number(),
+  added: z.array(z.string()),
+  checkedAt: z.number().nullable(),
+  /** Set with `skipped-cooldown`: milliseconds until a forced refresh is accepted again. */
+  retryAfterMs: z.number().optional(),
+  error: z.string().optional(),
+});
+
+export const ModelCatalogOverlayBodySchema = z.object({
+  provider: z.string().min(1),
+  modelId: z.string().min(1),
+  name: z.string().optional(),
+  family: z.string().optional(),
+  releaseDate: z.string().optional(),
+  contextWindow: z.number().int().positive().optional(),
+  maxOutput: z.number().int().positive().optional(),
+  reasoning: z.boolean().optional(),
+  reasoningOptions: z.array(ReasoningOptionSchema).optional(),
+  pricing: OverlayPricingSchema.optional(),
+  status: z.string().optional(),
+  reason: z.string().min(1),
+  verifiedBy: z.string().optional(),
+  expiresWhenUpstreamMatches: z.boolean().optional(),
+});
+
+const OverlayEntrySchema = ModelCatalogOverlayBodySchema.extend({
+  name: z.string().nullish(),
+  family: z.string().nullish(),
+  releaseDate: z.string().nullish(),
+  contextWindow: z.number().nullish(),
+  maxOutput: z.number().nullish(),
+  reasoning: z.boolean().nullish(),
+  reasoningOptions: z.array(ReasoningOptionSchema).nullish(),
+  pricing: OverlayPricingSchema.nullish(),
+  status: z.string().nullish(),
+  verifiedBy: z.string().nullish(),
+  expiresWhenUpstreamMatches: z.boolean(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
 const getCatalog = route({
   method: "get",
   path: "/api/models-catalog",
@@ -48,6 +130,192 @@ const getCatalog = route({
   },
 });
 
+const ModelTierPreviewSchema = z.object({
+  provider: ProviderNameSchema,
+  tier: z.enum(MODEL_TIERS),
+  key: z.string(),
+  defaultValue: z.string(),
+  configured: z.string().nullable(),
+  source: z.enum(["tier-config", "tier-default"]),
+  resolvedModel: z.string().nullable(),
+  alias: z.string().nullable(),
+});
+
+const getTiers = route({
+  method: "get",
+  path: "/api/models-catalog/tiers",
+  pattern: ["api", "models-catalog", "tiers"],
+  summary: "Preview what each model tier resolves to per harness provider",
+  description:
+    "One row per provider and tier: the built-in default, the `MODEL_TIER_<PROVIDER>_<TIER>` value stored in swarm config (if any), which layer wins, and the concrete model it resolves to against the current catalog (`latest:` aliases resolved with the same soak and auto-upgrade rules as claim time, without recording a resolution). Ignores per-worker `MODEL_TIER_*` overrides and per-task models.",
+  tags: ["Pricing"],
+  responses: {
+    200: {
+      description: "Tier previews",
+      schema: z.object({ tiers: z.array(ModelTierPreviewSchema) }),
+    },
+  },
+});
+
+const refreshCatalog = route({
+  method: "post",
+  path: "/api/models-catalog/refresh",
+  pattern: ["api", "models-catalog", "refresh"],
+  summary: "Refresh the model catalog from models.dev",
+  description:
+    "Unforced calls skip the network when the last models.dev check is younger than 4h (`skipped-fresh`). `force: true` always fetches, still conditional on the stored ETag (`not-modified` on 304), but a forced call within a minute of the previous one returns `skipped-cooldown` with `retryAfterMs`. Concurrent refreshes share one fetch. Lead agent or operator only. `added` lists provider/modelId keys new since the previous fetch.",
+  tags: ["Pricing"],
+  rbac: { permission: "models.catalog.write" },
+  body: z.object({ force: z.boolean().optional() }),
+  responses: {
+    200: { description: "Refresh outcome", schema: ModelCatalogRefreshResultSchema },
+    403: { description: "Forbidden" },
+  },
+});
+
+const upsertOverlay = route({
+  method: "put",
+  path: "/api/models-catalog/overlay",
+  pattern: ["api", "models-catalog", "overlay"],
+  summary: "Upsert one model-catalog overlay row",
+  description:
+    "Overlay facts win per non-null field over the models.dev row; overlay-only models are served too. Overlay prices fill pricing-table gaps (never override an active price). With `expiresWhenUpstreamMatches` (default true) the row is deleted once upstream matches every non-null fact.",
+  tags: ["Pricing"],
+  rbac: { permission: "models.catalog.write" },
+  body: ModelCatalogOverlayBodySchema,
+  responses: {
+    200: { description: "Overlay row upserted", schema: OverlayEntrySchema },
+    403: { description: "Forbidden" },
+  },
+});
+
+const deleteOverlay = route({
+  method: "delete",
+  path: "/api/models-catalog/overlay",
+  pattern: ["api", "models-catalog", "overlay"],
+  summary: "Delete one model-catalog overlay row",
+  tags: ["Pricing"],
+  rbac: { permission: "models.catalog.write" },
+  body: z.object({ provider: z.string().min(1), modelId: z.string().min(1) }),
+  responses: {
+    200: { description: "Overlay row deleted", schema: z.object({ deleted: z.boolean() }) },
+    403: { description: "Forbidden" },
+  },
+});
+
+const HarnessSupportRowSchema = z.object({
+  harness: z.string(),
+  cliVersion: z.string(),
+  modelId: z.string(),
+  status: z.enum(["ok", "unsupported", "unknown"]),
+  checkedAt: z.number(),
+  error: z.string().nullable(),
+});
+
+const listHarnessSupport = route({
+  method: "get",
+  path: "/api/models-catalog/harness-support",
+  pattern: ["api", "models-catalog", "harness-support"],
+  summary: "List harness CLI model support rows",
+  description:
+    "Whether a catalog model runs on a given `claude` / `codex` CLI version, as recorded by workers after a model's first run. No row means unknown (allowed at claim).",
+  tags: ["Pricing"],
+  query: z.object({ harness: z.string().optional(), cliVersion: z.string().optional() }),
+  responses: {
+    200: {
+      description: "Support rows, newest first",
+      schema: z.object({ rows: z.array(HarnessSupportRowSchema) }),
+    },
+  },
+});
+
+const recordHarnessSupport = route({
+  method: "put",
+  path: "/api/models-catalog/harness-support",
+  pattern: ["api", "models-catalog", "harness-support"],
+  summary: "Record whether a harness CLI version accepts a model",
+  description:
+    "Written by workers: `ok` after a model's first successful run, `unsupported` when the CLI rejects the model id. Claim-time resolution falls back (alias/tier) or fails fast (explicit model) on `unsupported`.",
+  tags: ["Pricing"],
+  rbac: { permission: "models.harness-support.write" },
+  body: z.object({
+    harness: z.string().min(1).max(32),
+    cliVersion: z.string().min(1).max(64),
+    modelId: z.string().min(1).max(200),
+    status: z.enum(["ok", "unsupported", "unknown"]),
+    error: z.string().max(4000).optional(),
+  }),
+  responses: {
+    200: { description: "Support row upserted", schema: HarnessSupportRowSchema },
+    403: { description: "Forbidden" },
+  },
+});
+
+/**
+ * Resolve the caller and gate on `verb`; writes a 403 on denial. Refresh and overlay writes
+ * (`models.catalog.write`) are lead or operator only. Harness support (`models.harness-support.write`)
+ * is a registered agent's report about its own CLI (bound to it by `callerOwnsSupportRow`) or an
+ * operator correction. Dashboard users can do neither.
+ *
+ * Trust boundary: a bound identity (an `aswt_` user token or an `aseph_` session token) is honoured
+ * as is. Beyond that, the shared swarm key is the operator credential and `X-Agent-ID` is
+ * self-declared, the same model `config.ts`, `mcp-servers.ts` and `extensions.ts` use. Every
+ * worker holds that key, so this gate stops a mistaken or ordinary worker call, not a worker that
+ * chooses to drop or forge the header; that needs per-agent credentials swarm-wide.
+ */
+async function ensureCatalogWriter(
+  req: IncomingMessage,
+  res: ServerResponse,
+  verb: "models.catalog.write" | "models.harness-support.write" = "models.catalog.write",
+): Promise<{ userId: string | null; agentId: string | null } | null> {
+  const auth = getRequestAuth(req);
+  const header = req.headers["x-agent-id"];
+  const agentId =
+    auth?.kind === "agent" ? auth.agentId : Array.isArray(header) ? header[0] : header;
+  let principal: RbacPrincipal;
+  if (auth?.kind === "user") {
+    principal = { kind: "user", userId: auth.userId };
+  } else if (agentId) {
+    // An X-Agent-ID wins over the shared API key: a worker holds that key, so treating it as the
+    // operator would let any worker skip the verb's lead-only rule.
+    const agent = await getAgentById(agentId);
+    principal = { kind: "agent", agentId, isLead: agent?.isLead ?? false };
+  } else if (auth?.kind === "operator") {
+    principal = { kind: "operator" };
+  } else {
+    principal = { kind: "agent", agentId: "", isLead: false };
+  }
+  const decision = can({
+    principal,
+    verb,
+    resource: { kind: "none" },
+    source: "http",
+  });
+  if (!decision.allow) {
+    jsonError(
+      res,
+      verb === "models.catalog.write"
+        ? "Writing the model catalog requires the lead agent or an operator"
+        : "Recording harness model support requires a registered agent or an operator",
+      403,
+    );
+    return null;
+  }
+  return {
+    userId: auth?.kind === "user" ? auth.userId : null,
+    agentId: principal.kind === "agent" && principal.agentId ? principal.agentId : null,
+  };
+}
+
+async function callerOwnsSupportRow(
+  agentId: string,
+  body: { harness: string; cliVersion: string },
+): Promise<boolean> {
+  const agent = await getAgentById(agentId);
+  if (!agent || agent.harnessProvider !== body.harness) return false;
+  return (await getAgentHarnessCliVersion(agentId)) === body.cliVersion;
+}
+
 export async function handleModelsCatalog(
   req: IncomingMessage,
   res: ServerResponse,
@@ -57,7 +325,88 @@ export async function handleModelsCatalog(
   if (getCatalog.match(req.method, pathSegments)) {
     const parsed = await getCatalog.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    json(res, getModelsCatalog());
+    getCatalog.respond(res, 200, await loadModelsCatalog());
+    return true;
+  }
+
+  if (getTiers.match(req.method, pathSegments)) {
+    const parsed = await getTiers.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    getTiers.respond(res, 200, { tiers: await previewModelTiers() });
+    return true;
+  }
+
+  if (refreshCatalog.match(req.method, pathSegments)) {
+    const parsed = await refreshCatalog.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!(await ensureCatalogWriter(req, res))) return true;
+    refreshCatalog.respond(
+      res,
+      200,
+      await requestModelCatalogRefresh({ force: parsed.body.force }),
+    );
+    return true;
+  }
+
+  if (upsertOverlay.match(req.method, pathSegments)) {
+    const parsed = await upsertOverlay.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const writer = await ensureCatalogWriter(req, res);
+    if (!writer) return true;
+    const entry = await upsertModelCatalogOverlay(parsed.body, { userId: writer.userId });
+    upsertOverlay.respond(res, 200, entry);
+    return true;
+  }
+
+  if (deleteOverlay.match(req.method, pathSegments)) {
+    const parsed = await deleteOverlay.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!(await ensureCatalogWriter(req, res))) return true;
+    const deleted = await deleteModelCatalogOverlay(parsed.body.provider, parsed.body.modelId);
+    deleteOverlay.respond(res, 200, { deleted });
+    return true;
+  }
+
+  if (listHarnessSupport.match(req.method, pathSegments)) {
+    const parsed = await listHarnessSupport.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    listHarnessSupport.respond(res, 200, { rows: await listHarnessModelSupport(parsed.query) });
+    return true;
+  }
+
+  if (recordHarnessSupport.match(req.method, pathSegments)) {
+    const parsed = await recordHarnessSupport.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const writer = await ensureCatalogWriter(req, res, "models.harness-support.write");
+    if (!writer) return true;
+    if (writer.agentId && !(await callerOwnsSupportRow(writer.agentId, parsed.body))) {
+      // Support rows are shared per (harness, CLI version), so a worker may only write the row
+      // for the harness and CLI version it registered, never an arbitrary tuple.
+      jsonError(
+        res,
+        "Harness support can only be recorded for the calling agent's own harness and registered CLI version",
+        403,
+      );
+      return true;
+    }
+    if (
+      writer.agentId &&
+      parsed.body.status === "unsupported" &&
+      !(
+        isUnknownModelError(parsed.body.error, parsed.body.modelId) &&
+        (await agentRanModel(writer.agentId, parsed.body.modelId))
+      )
+    ) {
+      // An `unsupported` row changes claims on every peer with this CLI, so an agent may only
+      // report it for a model it was assigned, with the CLI's model-rejection text.
+      jsonError(
+        res,
+        "An unsupported report needs a model the calling agent ran and the CLI's model-rejection error",
+        403,
+      );
+      return true;
+    }
+    recordHarnessSupport.respond(res, 200, await recordHarnessModelSupport(parsed.body));
     return true;
   }
 

package/src/http/poll.ts

@@ -28,6 +28,11 @@ import {
   upsertChannelActivityCursor,
 } from "../be/db";
 import { renderIdentity, resolveIdentity } from "../be/identity";
+import {
+  parseModelTierOverridesHeader,
+  recordClaimModelResolution,
+  setAgentModelTierOverrides,
+} from "../be/model-tier-resolution";
 import { touchRuntimeInstance } from "../be/multi-runtime";
 import { hasCapability } from "../server";
 import { fetchChannelActivity } from "../slack/channel-activity";
@@ -168,7 +173,15 @@ const pollTriggers = route({
   summary: "Poll for triggers (tasks, mentions)",
   tags: ["Poll"],
   auth: { apiKey: true, agentId: true },
-  headers: runtimeInstanceHeader("poll for work"),
+  headers: runtimeInstanceHeader("poll for work").extend({
+    "X-Model-Tier-Overrides": z
+      .string()
+      .optional()
+      .describe(
+        "URL-encoded JSON {provider: {tier: model}} of the worker's MODEL_TIER_* env overrides. " +
+          "Stored on the agent row and applied at claim time (modelSource=worker-env).",
+      ),
+  }),
   responses: {
     200: { description: "Trigger data or null", schema: pollResponseSchema },
     400: { description: "Missing X-Agent-ID" },
@@ -230,6 +243,22 @@ async function attachmentsForTrigger(
   }));
 }
 
+/**
+ * Claim-time model resolution (runbooks/model-tiers.md). Never blocks a claim:
+ * a resolution failure leaves the worker on its own local resolution.
+ */
+async function claimModelFields(
+  task: { id: string; model?: string | null; modelTier?: string | null },
+  agent: Parameters<typeof recordClaimModelResolution>[1],
+): Promise<Awaited<ReturnType<typeof recordClaimModelResolution>>> {
+  try {
+    return await recordClaimModelResolution(task, agent);
+  } catch (error) {
+    console.warn(`[/api/poll] model resolution failed for task ${task.id}:`, error);
+    return {};
+  }
+}
+
 // ─── Cursor Commit Endpoint ─────────────────────────────────────────────────
 
 const commitCursorsRoute = route({
@@ -268,6 +297,9 @@ export async function handlePoll(
   const runtimeInstanceId = ((h) => (Array.isArray(h) ? h[0] : h))(
     req.headers["x-runtime-instance-id"],
   );
+  const modelTierOverrides = parseModelTierOverridesHeader(
+    ((h) => (Array.isArray(h) ? h[0] : h))(req.headers["x-model-tier-overrides"]),
+  );
   // Handle cursor commit endpoint
   if (commitCursorsRoute.match(req.method, pathSegments)) {
     const parsed = await commitCursorsRoute.parse(req, res, pathSegments, queryParams);
@@ -311,6 +343,12 @@ export async function handlePoll(
           return { error: "Agent not found", status: 404 };
         }
 
+        // The worker's parsed MODEL_TIER_* env overrides ride on every poll so
+        // claim-time resolution can honor them (no write when unchanged).
+        if (modelTierOverrides) {
+          await setAgentModelTierOverrides(agent.id, modelTierOverrides);
+        }
+
         // Extension identities authenticate to the API but never execute
         // work: no offers, no pending assignments, no pool claims.
         if (isExtensionAgent(agent)) {
@@ -448,6 +486,7 @@ export async function handlePoll(
                 taskId: pendingTask.id,
                 task: {
                   ...pendingTask,
+                  ...(await claimModelFields(pendingTask, agent)),
                   status: "in_progress",
                   attachments: await attachmentsForTrigger(pendingTask.id),
                 },
@@ -576,7 +615,11 @@ export async function handlePoll(
                   trigger: {
                     type: "task_assigned",
                     taskId: claimed.id,
-                    task: { ...claimed, attachments: await attachmentsForTrigger(claimed.id) },
+                    task: {
+                      ...claimed,
+                      ...(await claimModelFields(claimed, agent)),
+                      attachments: await attachmentsForTrigger(claimed.id),
+                    },
                     ...(claimedRequestedBy && { requestedBy: claimedRequestedBy }),
                   },
                 };

package/src/http/schedules.ts

@@ -16,6 +16,7 @@ import {
   updateScheduledTask,
   withFavoriteFlags,
 } from "../be/db";
+import { explicitModelErrorForAgent } from "../be/model-validation";
 import { mergeScheduleTiming, validateRecurringTiming } from "../be/schedules/validate";
 import { getScript } from "../be/scripts/db";
 import { calculateNextRun, dispatchScheduleTarget } from "../scheduler/scheduler";
@@ -49,6 +50,8 @@ const scheduleUpdateBodySchema = z.object({
   timezone: z.string().optional(),
   model: z.string().nullable().optional(),
   modelTier: ModelTierSchema.nullable().optional(),
+  /** Accept a `model` the catalog does not list (a custom id). Without it an unknown id is a 400. */
+  allowCustomModel: z.boolean().optional(),
   nextRunAt: z.string().nullable().optional(),
   targetType: ScheduledTaskTargetTypeSchema.optional(),
   workflowId: z.string().uuid().nullable().optional(),
@@ -108,6 +111,8 @@ const createSchedule = route({
     timezone: z.string().optional(),
     model: z.string().optional(),
     modelTier: ModelTierSchema.optional(),
+    /** Accept a `model` the catalog does not list (a custom id). Without it an unknown id is a 400. */
+    allowCustomModel: z.boolean().optional(),
     scheduleType: z.enum(["recurring", "one_time"]).optional(),
     targetType: ScheduledTaskTargetTypeSchema.optional(),
     workflowId: z.string().uuid().optional(),
@@ -389,6 +394,16 @@ export async function handleSchedules(
       }
     }
 
+    const modelError = await explicitModelErrorForAgent({
+      model: splitLegacyModelAlias({ model: body.model, modelTier: body.modelTier }).model,
+      allowCustomModel: body.allowCustomModel,
+      agentId: body.targetAgentId,
+    });
+    if (modelError) {
+      jsonError(res, modelError, 400);
+      return true;
+    }
+
     try {
       const trustedUserId = await resolveHttpAuditUserId(req, myAgentId);
       let key: string | undefined;
@@ -535,23 +550,38 @@ export async function handleSchedules(
         throw error;
       }
     }
+    // The escape hatch is a request flag, not a schedule column. `body` aliases
+    // `parsed.body`, so read the flag before stripping it.
+    const allowCustomModel = parsed.body.allowCustomModel;
+    delete body.allowCustomModel;
+    const existing = await getScheduledTaskById(parsed.params.id);
+    if (!existing) {
+      jsonError(res, "Schedule not found", 404);
+      return true;
+    }
     if (parsed.body.model !== undefined || parsed.body.modelTier !== undefined) {
       const normalizedModel = splitLegacyModelAlias({
         model: parsed.body.model,
         modelTier: parsed.body.modelTier,
       });
+      // A model the schedule already stores is not re-judged, so an unrelated edit still saves.
+      if (normalizedModel.model !== existing.model) {
+        const modelError = await explicitModelErrorForAgent({
+          model: normalizedModel.model,
+          allowCustomModel,
+          agentId: parsed.body.targetAgentId ?? existing.targetAgentId,
+        });
+        if (modelError) {
+          jsonError(res, modelError, 400);
+          return true;
+        }
+      }
       if (parsed.body.model !== undefined) body.model = normalizedModel.model ?? null;
       if (parsed.body.modelTier !== undefined || normalizedModel.modelTier) {
         body.modelTier = normalizedModel.modelTier ?? null;
       }
     }
 
-    const existing = await getScheduledTaskById(parsed.params.id);
-    if (!existing) {
-      jsonError(res, "Schedule not found", 404);
-      return true;
-    }
-
     // Reject updates on completed one-time schedules
     if (existing.scheduleType === "one_time" && !existing.enabled && existing.lastRunAt) {
       jsonError(res, "One-time schedule has already executed. Create a new one instead.", 400);

package/src/http/session-data.ts

@@ -13,7 +13,6 @@ import {
   getSessionCostsFiltered,
   getSessionLogsByTaskId,
   getTaskById,
-  getUsageDataVersion,
 } from "../be/db";
 import { recordSessionCost } from "../otel";
 import { incrementServerSessionsProcessed } from "../server-runtime-counters";
@@ -457,8 +456,7 @@ export async function handleSessionData(
       userId: parsed.query.userId || undefined,
       groupBy: parsed.query.groupBy || "both",
     } as const;
-    const version = await getUsageDataVersion();
-    const summary = await cachedUsageReport(`summary:${version}:${JSON.stringify(opts)}`, () =>
+    const summary = await cachedUsageReport(`summary:${JSON.stringify(opts)}`, () =>
       getSessionCostSummary(opts),
     );
     getSessionCostSummaryRoute.respond(res, 200, summary);
@@ -478,8 +476,7 @@ export async function handleSessionData(
       startDate: parsed.query.startDate || undefined,
       endDate: parsed.query.endDate || undefined,
     };
-    const version = await getUsageDataVersion();
-    const rows = await cachedUsageReport(`attribution:${version}:${JSON.stringify(opts)}`, () =>
+    const rows = await cachedUsageReport(`attribution:${JSON.stringify(opts)}`, () =>
       getAttributionByPerson(opts),
     );
     getAttributionByPersonRoute.respond(res, 200, { rows });

package/src/http/stats.ts

@@ -1,7 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import {
-  getAllAgents,
+  getAgentStatusCounts,
   getAllLogs,
   getAllServices,
   getConcurrentContext,
@@ -15,6 +15,7 @@ import { getDbRetentionStats } from "../be/db-retention";
 import { isSteeringEnabled } from "../be/steering";
 import type { AgentLog } from "../types";
 import { AgentLogSchema, ScheduledTaskSchema, ServiceSchema } from "../types";
+import { isEnvFlagEnabled } from "../utils/env-flag";
 import { isMultiRuntimeEnabled } from "../utils/multi-runtime";
 import { resolveHttpFavoriteOwner } from "./favorite-owner";
 import { route } from "./route-def";
@@ -51,6 +52,7 @@ const DashboardStatsSchema = z.object({
   tasks: TaskCountsSchema,
   steeringEnabled: z.boolean(),
   multiRuntimeEnabled: z.boolean(),
+  devMode: z.boolean(),
 });
 
 /** Mirrors `DbRetentionTableStats` (src/be/db-retention.ts). */
@@ -247,16 +249,11 @@ export async function handleStats(
   }
 
   if (getStats.match(req.method, pathSegments)) {
-    const agents = await getAllAgents();
+    const agents = await getAgentStatusCounts();
     const taskStats = await getTaskStats();
 
     const stats = {
-      agents: {
-        total: agents.length,
-        idle: agents.filter((a) => a.status === "idle").length,
-        busy: agents.filter((a) => a.status === "busy").length,
-        offline: agents.filter((a) => a.status === "offline").length,
-      },
+      agents,
       tasks: {
         total: taskStats.total,
         unassigned: taskStats.unassigned,
@@ -271,6 +268,7 @@ export async function handleStats(
       // Authenticated home for the steering feature flag — deliberately NOT on
       // the unauthenticated /health endpoint (config must not leak).
       steeringEnabled: isSteeringEnabled(),
+      devMode: isEnvFlagEnabled("SWARM_DEV_MODE", false),
       // Same authenticated home, for the same reason. Read through the helper
       // the server itself branches on, and read PER REQUEST rather than
       // captured at module load, so the reported value tracks a `swarm_config`