@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/src/be/models-catalog.ts

@@ -60,8 +60,12 @@ export interface CatalogReasoningOption {
 export interface CatalogModel {
   id: string;
   name?: string;
-  cost?: { input?: number; output?: number };
+  cost?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
   limit?: { context?: number };
+  /** models.dev `release_date` (ISO date). Drives newest-first ordering in harness lists. */
+  release_date?: string;
+  /** models.dev `status` (e.g. "deprecated"). Deprecated models drop out of harness lists. */
+  status?: string;
   reasoning?: boolean;
   reasoning_options?: CatalogReasoningOption[];
 }
@@ -94,9 +98,20 @@ function slimModel(modelKey: string, model: ModelsDevModel): CatalogModel {
     id: model.id ?? modelKey,
     ...(model.name !== undefined ? { name: model.name } : {}),
     ...(model.cost !== undefined
-      ? { cost: { input: model.cost.input, output: model.cost.output } }
+      ? {
+          cost: {
+            input: model.cost.input,
+            output: model.cost.output,
+            ...(model.cost.cache_read !== undefined ? { cache_read: model.cost.cache_read } : {}),
+            ...(model.cost.cache_write !== undefined
+              ? { cache_write: model.cost.cache_write }
+              : {}),
+          },
+        }
       : {}),
     ...(model.limit?.context !== undefined ? { limit: { context: model.limit.context } } : {}),
+    ...(typeof model.release_date === "string" ? { release_date: model.release_date } : {}),
+    ...(typeof model.status === "string" ? { status: model.status } : {}),
     ...(model.reasoning !== undefined ? { reasoning: model.reasoning } : {}),
     ...(reasoningOptions.length > 0 ? { reasoning_options: reasoningOptions } : {}),
   };
@@ -148,22 +163,61 @@ function mergePinnedEntries(catalog: ModelsCatalog): void {
   }
 }
 
-/** Called by the pricing-refresh loop after every successful full models.dev fetch. */
-export function updateLiveModelsCatalog(cache: ModelsDevCache, now = Date.now()): void {
-  const catalog = buildModelsCatalog(cache);
+/**
+ * Install a freshly built live catalog (already merged with the persistent
+ * table + overlay by `src/be/model-catalog-store.ts`). Pinned snapshot entries
+ * are re-merged so they never drop out of the picker.
+ */
+export function setLiveModelsCatalog(catalog: ModelsCatalog, updatedAt: number | null): void {
   mergePinnedEntries(catalog);
   liveCatalog = catalog;
-  liveUpdatedAt = now;
+  liveUpdatedAt = updatedAt;
+}
+
+/**
+ * Legacy in-memory update from a raw models.dev payload. The refresh path now
+ * persists to `model_catalog` and reloads via `reloadModelsCatalog()`; this
+ * stays for callers/tests that only have a payload in hand.
+ */
+export function updateLiveModelsCatalog(cache: ModelsDevCache, now = Date.now()): void {
+  setLiveModelsCatalog(buildModelsCatalog(cache), now);
+}
+
+/** Drop the in-memory catalog so the next async read rebuilds it from the DB. */
+export function invalidateModelsCatalog(): void {
+  liveCatalog = null;
+  liveUpdatedAt = null;
+  snapshotOverride = null;
+}
+
+export function isModelsCatalogLoaded(): boolean {
+  return liveCatalog !== null;
+}
+
+/** Deep copy of the slimmed vendored snapshot (safe to mutate). */
+export function snapshotModelsCatalog(): ModelsCatalog {
+  return structuredClone(bundledSnapshotCatalog());
+}
+
+/** Snapshot with overlay rows layered on; served while the table is empty. */
+let snapshotOverride: ModelsCatalog | null = null;
+export function setSnapshotOverlayCatalog(catalog: ModelsCatalog | null): void {
+  snapshotOverride = catalog;
 }
 
 export function getModelsCatalog(): ModelsCatalogResult {
   if (liveCatalog) {
     return { source: "live", updatedAt: liveUpdatedAt, providers: liveCatalog };
   }
-  return { source: "snapshot", updatedAt: null, providers: bundledSnapshotCatalog() };
+  return {
+    source: "snapshot",
+    updatedAt: null,
+    providers: snapshotOverride ?? bundledSnapshotCatalog(),
+  };
 }
 
 export function resetModelsCatalogForTests(): void {
   liveCatalog = null;
   liveUpdatedAt = null;
+  snapshotOverride = null;
 }

package/src/be/modelsdev-cache.json

@@ -287104,6 +287104,88 @@
           "cache_read": 2.5
         }
       },
+      "gpt-6.1-sol": {
+        "id": "gpt-6.1-sol",
+        "name": "GPT-6.1 Sol",
+        "description": "Near-Astra performance for complex work at a lower cost",
+        "family": "gpt-sol",
+        "attachment": true,
+        "reasoning": true,
+        "reasoning_options": [
+          {
+            "type": "effort",
+            "values": [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          }
+        ],
+        "tool_call": true,
+        "structured_output": true,
+        "temperature": false,
+        "knowledge": "2026-04-30",
+        "release_date": "2026-09-29",
+        "last_updated": "2026-09-29",
+        "modalities": {
+          "input": [
+            "text",
+            "image"
+          ],
+          "output": [
+            "text"
+          ]
+        },
+        "open_weights": false,
+        "limit": {
+          "context": 1050000,
+          "input": 922000,
+          "output": 128000
+        },
+        "experimental": {
+          "modes": {
+            "fast": {
+              "cost": {
+                "input": 4,
+                "output": 20,
+                "cache_read": 0.2,
+                "cache_write": 5
+              },
+              "provider": {
+                "body": {
+                  "service_tier": "priority"
+                }
+              }
+            }
+          }
+        },
+        "cost": {
+          "input": 2,
+          "output": 10,
+          "cache_read": 0.1,
+          "cache_write": 2.5,
+          "tiers": [
+            {
+              "input": 4,
+              "output": 15,
+              "cache_read": 0.2,
+              "cache_write": 5,
+              "tier": {
+                "type": "context",
+                "size": 272000
+              }
+            }
+          ],
+          "context_over_200k": {
+            "input": 4,
+            "output": 15,
+            "cache_read": 0.2,
+            "cache_write": 5
+          }
+        }
+      },
       "gpt-6-sol": {
         "id": "gpt-6-sol",
         "name": "GPT-6 Sol",

package/src/be/modelsdev-cache.ts

@@ -18,6 +18,8 @@ export interface ModelsDevModel {
   name?: string;
   cost?: ModelsDevCostBlock;
   limit?: { context?: number };
+  release_date?: string;
+  status?: string;
   reasoning?: boolean;
   reasoning_options?: ModelsDevReasoningOption[];
 }

package/src/be/pricing-refresh.ts

@@ -6,14 +6,25 @@ import {
   type InsertPricingRowInput,
   insertPricingRow,
 } from "./db";
-import { updateLiveModelsCatalog } from "./models-catalog";
+import {
+  applyOverlayPricingRows,
+  buildCatalogEntries,
+  countModelCatalog,
+  expireMatchedOverlays,
+  getModelCatalogMeta,
+  reloadModelsCatalog,
+  replaceModelCatalog,
+  touchModelCatalogCheckedAt,
+  updateModelCatalogMeta,
+} from "./model-catalog-store";
 import type { ModelsDevCache } from "./modelsdev-cache";
 import { buildModelsDevSeedRows, type PricingSeedRow } from "./seed-pricing";
 
 const MODELSDEV_API_URL = "https://models.dev/api.json";
 export const PRICING_REFRESH_INTERVAL_MS = 12 * 60 * 60 * 1000;
+/** Unforced `refreshModelCatalog()` calls skip the network when the last models.dev check (200 or 304) is younger than this. */
+export const MODEL_CATALOG_FRESH_MS = 4 * 60 * 60 * 1000;
 
-let lastETag: string | null = null;
 let refreshLoopStarted = false;
 
 interface RefreshPricingOptions {
@@ -28,6 +39,11 @@ export interface PricingRefreshResult {
   unchanged: number;
   pruned: number;
   etag?: string;
+  /** Catalog keys ("provider/modelId") new since the previous fetch. */
+  added?: string[];
+  /** Overlay rows auto-expired because upstream now matches. */
+  expiredOverlays?: string[];
+  catalogModels?: number;
 }
 
 function logPricingRefresh(message: string): void {
@@ -129,17 +145,29 @@ export async function refreshPricingFromModelsDev(
 ): Promise<PricingRefreshResult> {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const now = opts.now ?? Date.now();
-  const headers: Record<string, string> = lastETag ? { "If-None-Match": lastETag } : {};
+  const meta = await getModelCatalogMeta();
+  // Only send validators when the table is populated — a 304 against an empty
+  // table (fresh DB, same ETag) would leave the catalog empty.
+  const catalogCount = await countModelCatalog();
+  const headers: Record<string, string> = {};
+  if (catalogCount > 0 && meta.etag) headers["If-None-Match"] = meta.etag;
+  if (catalogCount > 0 && meta.lastModified) headers["If-Modified-Since"] = meta.lastModified;
 
   const response = await fetchImpl(MODELSDEV_API_URL, { headers });
   if (response.status === 304) {
+    await touchModelCatalogCheckedAt(now);
+    await updateModelCatalogMeta({ lastCheckedAt: now });
+    await reloadModelsCatalog();
     const result: PricingRefreshResult = {
       status: "not_modified",
       candidateRows: 0,
       inserted: 0,
       unchanged: 0,
       pruned: 0,
-      etag: lastETag ?? undefined,
+      etag: meta.etag ?? undefined,
+      added: [],
+      expiredOverlays: [],
+      catalogModels: catalogCount,
     };
     await auditPricingRefresh(result);
     logPricingRefresh("models.dev returned 304; pricing rows unchanged");
@@ -151,36 +179,150 @@ export async function refreshPricingFromModelsDev(
 
   const cache = (await response.json()) as ModelsDevCache;
   const etag = response.headers.get("etag");
-  updateLiveModelsCatalog(cache, now);
+  const lastModified = response.headers.get("last-modified");
+  const entries = buildCatalogEntries(cache, now);
+  const added = await replaceModelCatalog(entries);
   const rows = buildModelsDevSeedRows(cache);
   const { inserted, unchanged } = await insertChangedPricingRows(rows, now);
+  const expiredOverlays = await expireMatchedOverlays();
+  // Overlay prices only fill (provider, model, tokenClass) gaps upstream left.
+  const overlayInserted = await applyOverlayPricingRows(now);
   const pruned = await prunePricingHistory(2);
-  lastETag = etag;
+  await updateModelCatalogMeta({ etag, lastModified, lastFetchAt: now, lastCheckedAt: now });
+  await reloadModelsCatalog();
 
   const result: PricingRefreshResult = {
     status: "refreshed",
     candidateRows: rows.length,
-    inserted,
+    inserted: inserted + overlayInserted,
     unchanged,
     pruned,
-    etag: lastETag ?? undefined,
+    etag: etag ?? undefined,
+    added,
+    expiredOverlays,
+    catalogModels: entries.length,
   };
   await auditPricingRefresh(result);
   logPricingRefresh(
-    `refreshed ${rows.length} candidate row(s); inserted=${inserted}; unchanged=${unchanged}; pruned=${pruned}`,
+    `refreshed ${rows.length} candidate row(s); inserted=${inserted}; unchanged=${unchanged}; pruned=${pruned}; catalog=${entries.length}; added=${added.length}; expiredOverlays=${expiredOverlays.length}`,
   );
   return result;
 }
 
-async function runPricingRefreshSafely(): Promise<void> {
+export interface ModelCatalogRefreshResult {
+  status: "updated" | "not-modified" | "skipped-fresh" | "skipped-cooldown" | "error";
+  models: number;
+  added: string[];
+  checkedAt: number | null;
+  /** Set with `skipped-cooldown`: milliseconds until a forced refresh is accepted again. */
+  retryAfterMs?: number;
+  error?: string;
+}
+
+/** Minimum gap between forced refreshes accepted from callers (HTTP route, MCP tool). */
+export const MODEL_CATALOG_FORCE_COOLDOWN_MS = 60 * 1000;
+
+let refreshInFlight: Promise<ModelCatalogRefreshResult> | null = null;
+let lastForcedRefreshAt: number | null = null;
+
+/** Test-only: forget the in-flight refresh and the forced-refresh cooldown. */
+export function resetModelCatalogRefreshGuardForTests(): void {
+  refreshInFlight = null;
+  lastForcedRefreshAt = null;
+}
+
+/**
+ * `pi update --models` for the swarm. Unforced calls skip the network when the
+ * last fetch is younger than MODEL_CATALOG_FRESH_MS; `force` always fetches
+ * (still conditional on the stored ETag). Never throws — failures come back as
+ * `status: "error"` and the catalog keeps serving the last good table (or the
+ * vendored snapshot).
+ */
+export function refreshModelCatalog(
+  opts: { force?: boolean } & RefreshPricingOptions = {},
+): Promise<ModelCatalogRefreshResult> {
+  // Single flight: a refresh that is already running serves every concurrent caller, so a burst of
+  // requests (or the boot loop racing a forced call) costs one models.dev fetch.
+  if (refreshInFlight) return refreshInFlight;
+  const run = runModelCatalogRefresh(opts).finally(() => {
+    if (refreshInFlight === run) refreshInFlight = null;
+  });
+  refreshInFlight = run;
+  return run;
+}
+
+/**
+ * Caller-facing entry for the HTTP route and the MCP tool: `refreshModelCatalog` plus a cooldown
+ * on `force`. A forced call within MODEL_CATALOG_FORCE_COOLDOWN_MS of the previous one does not
+ * fetch; it reports `skipped-cooldown` and how long to wait. Unforced calls pass straight through
+ * (they already skip the network while the table is fresh).
+ */
+export async function requestModelCatalogRefresh(
+  opts: { force?: boolean } & RefreshPricingOptions = {},
+): Promise<ModelCatalogRefreshResult> {
+  const now = opts.now ?? Date.now();
+  if (opts.force) {
+    const waitMs =
+      lastForcedRefreshAt === null
+        ? 0
+        : lastForcedRefreshAt + MODEL_CATALOG_FORCE_COOLDOWN_MS - now;
+    if (waitMs > 0) {
+      const meta = await getModelCatalogMeta().catch(() => null);
+      return {
+        status: "skipped-cooldown",
+        models: await countModelCatalog().catch(() => 0),
+        added: [],
+        checkedAt: meta?.lastCheckedAt ?? null,
+        retryAfterMs: waitMs,
+      };
+    }
+    lastForcedRefreshAt = now;
+  }
+  return refreshModelCatalog({ ...opts, now });
+}
+
+async function runModelCatalogRefresh(
+  opts: { force?: boolean } & RefreshPricingOptions = {},
+): Promise<ModelCatalogRefreshResult> {
+  const now = opts.now ?? Date.now();
   try {
-    await refreshPricingFromModelsDev();
+    const meta = await getModelCatalogMeta();
+    const count = await countModelCatalog();
+    if (
+      !opts.force &&
+      count > 0 &&
+      meta.lastCheckedAt !== null &&
+      now - meta.lastCheckedAt < MODEL_CATALOG_FRESH_MS
+    ) {
+      await reloadModelsCatalog();
+      return { status: "skipped-fresh", models: count, added: [], checkedAt: meta.lastCheckedAt };
+    }
+    const result = await refreshPricingFromModelsDev({ fetchImpl: opts.fetchImpl, now });
+    return {
+      status: result.status === "refreshed" ? "updated" : "not-modified",
+      models: result.catalogModels ?? (await countModelCatalog()),
+      added: result.added ?? [],
+      checkedAt: now,
+    };
   } catch (err) {
-    logPricingRefreshError("refresh failed", err);
+    logPricingRefreshError("model catalog refresh failed", err);
     await auditPricingRefreshFailure(err);
+    const meta = await getModelCatalogMeta().catch(() => null);
+    return {
+      status: "error",
+      models: await countModelCatalog().catch(() => 0),
+      added: [],
+      checkedAt: meta?.lastCheckedAt ?? null,
+      error: scrubSecrets(err instanceof Error ? err.message : String(err)),
+    };
   }
 }
 
+async function runPricingRefreshSafely(): Promise<void> {
+  // refreshModelCatalog never throws; errors are logged + audited inside.
+  await refreshModelCatalog();
+}
+
 export function startPricingRefreshLoop(): void {
   if (refreshLoopStarted) return;
   refreshLoopStarted = true;

package/src/be/scripts/typecheck.ts

@@ -262,6 +262,21 @@ export interface SwarmSdk {
   config_set(args: { key: string; value: unknown; scope?: "global" | "agent" | "repo"; scopeId?: string; isSecret?: boolean }): Promise<unknown>;
   config_delete(args: { id: string }): Promise<unknown>;
 
+  // --- write: model catalog ---
+  modelCatalog_refresh(args?: { force?: boolean }): Promise<unknown>;
+  modelCatalog_overlayUpsert(args: {
+    provider: string;
+    modelId: string;
+    name?: string;
+    releaseDate?: string;
+    contextWindow?: number;
+    maxOutput?: number;
+    reasoningOptions?: Array<{ type: string; values?: string[] }>;
+    pricing?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
+    reason: string;
+    verifiedBy?: string;
+  }): Promise<unknown>;
+
   // --- write: slack ---
   slack_post(args: { channelId: string; message: string; blocks?: unknown }): Promise<unknown>;
   slack_reply(args: { channelId?: string; threadTs?: string; message: string; taskId?: string; blocks?: unknown }): Promise<unknown>;

package/src/be/seed-scripts/catalog/task-failure-audit.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { publishCatalogReportPage } from "./catalog-report";
 
+const MAX_TASK_SCAN_LIMIT = 500;
+
 export const argsSchema = z.object({
   days: z
     .number()
@@ -16,8 +18,9 @@ export const argsSchema = z.object({
     .number()
     .int()
     .positive()
+    .max(MAX_TASK_SCAN_LIMIT)
     .optional()
-    .describe("Max failed tasks to scan (default 500)"),
+    .describe("Max failed tasks to scan (default 500, max 500)"),
   publishPage: z.boolean().optional().describe("Publish an authed HTML page (default true)"),
 });
 
@@ -25,20 +28,37 @@ const REASON_PATTERNS: any[] = [
   { key: "sigterm/killed", re: /sigterm|sigkill|killed|143|137/i },
   { key: "timeout", re: /time?d?\s*out|timeout|deadline/i },
   { key: "context-window", re: /context (window|limit|saturat)|peakcontext|compact/i },
+  { key: "reboot-sweep", re: /reboot sweep/i },
   { key: "not-found", re: /not found|404|missing|no such/i },
   { key: "auth/credentials", re: /unauthorized|401|403|credential|token|forbidden/i },
-  { key: "ci/checks-failed", re: /ci|check.?s? fail|lint|tsc|test.?s? fail/i },
+  { key: "ci/checks-failed", re: /\bci\b|check.?s? fail|lint|tsc|test.?s? fail/i },
   { key: "network", re: /network|econn|fetch failed|socket|dns|502|503|504/i },
   { key: "cancelled", re: /cancel|aborted/i },
 ];
 
+function sanitizeUntrustedReasonSample(reason: unknown): string {
+  return String(reason)
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 200);
+}
+
+function rowsToObjects(result: any): any[] {
+  const payload = result?.data ?? result;
+  const columns: string[] = payload?.columns ?? [];
+  return (payload?.rows ?? []).map((row: any) =>
+    Array.isArray(row) ? Object.fromEntries(columns.map((column, i) => [column, row[i]])) : row,
+  );
+}
+
 function reasonCluster(reason: string): string {
   const r = (reason || "").trim();
   if (!r) return "(no reason given)";
   for (const p of REASON_PATTERNS) {
     if (p.re.test(r)) return p.key;
   }
-  return r.toLowerCase().slice(0, 48);
+  return "other";
 }
 
 /** Cluster recently failed swarm tasks by reason, agent, or schedule. */
@@ -47,7 +67,7 @@ export default async function taskFailureAudit(args: any, ctx: any) {
   if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
   const days = parsed.data.days || 7;
   const groupBy = parsed.data.groupBy || "reason";
-  const limit = parsed.data.limit || 500;
+  const limit = Math.min(parsed.data.limit ?? MAX_TASK_SCAN_LIMIT, MAX_TASK_SCAN_LIMIT);
   const publishPage = parsed.data.publishPage !== false;
 
   const since = new Date(Date.now() - days * 86400000).toISOString();
@@ -62,17 +82,49 @@ export default async function taskFailureAudit(args: any, ctx: any) {
   const payload: any = res && res.data ? res.data : res;
   const tasks: any = payload && Array.isArray(payload.tasks) ? payload.tasks : [];
 
+  const failureReasons = new Map<string, string>();
+  if (groupBy === "reason") {
+    const tasksNeedingReason = tasks.filter((task: any) => !task.failureReason && task.id);
+    const taskIds = tasksNeedingReason.map((task: any) => task.id as string);
+    if (taskIds.length > 0) {
+      const placeholders = taskIds.map(() => "?").join(", ");
+      const reasonResult: any = await ctx.swarm.db_query({
+        sql: `SELECT id, failureReason FROM agent_tasks WHERE id IN (${placeholders})`,
+        params: taskIds,
+      });
+      const reasonPayload: any = reasonResult?.data ?? reasonResult;
+      if (
+        reasonResult?.success === false ||
+        reasonPayload?.success === false ||
+        reasonPayload?.error
+      ) {
+        return { error: "failure reason projection failed with status " + reasonResult?.status };
+      }
+      if (reasonPayload?.truncated) {
+        return {
+          error: `failure reason projection truncated (${reasonPayload.rows?.length ?? 0} of ${reasonPayload.total ?? "unknown"} rows)`,
+        };
+      }
+      for (const row of rowsToObjects(reasonResult)) {
+        if (typeof row?.id === "string" && typeof row.failureReason === "string") {
+          failureReasons.set(row.id, row.failureReason);
+        }
+      }
+    }
+  }
+
   const groups: any = {};
   for (const t of tasks) {
     let key: string;
     if (groupBy === "agent") key = t.agentId || "(unassigned)";
     else if (groupBy === "schedule") key = t.scheduleId || "(not scheduled)";
-    else key = reasonCluster(t.failureReason || "");
-    if (!groups[key]) groups[key] = { key, count: 0, taskIds: [], sampleReason: "" };
+    else key = reasonCluster(failureReasons.get(t.id) || t.failureReason || "");
+    if (!groups[key]) groups[key] = { key, count: 0, taskIds: [], untrustedWorkerTextSample: "" };
     groups[key].count++;
     if (groups[key].taskIds.length < 5) groups[key].taskIds.push(t.id);
-    if (!groups[key].sampleReason && t.failureReason) {
-      groups[key].sampleReason = String(t.failureReason).slice(0, 200);
+    const failureReason = failureReasons.get(t.id) || t.failureReason;
+    if (!groups[key].untrustedWorkerTextSample && failureReason) {
+      groups[key].untrustedWorkerTextSample = sanitizeUntrustedReasonSample(failureReason);
     }
   }
 
@@ -118,7 +170,7 @@ export default async function taskFailureAudit(args: any, ctx: any) {
                   key: group.key,
                   count: group.count,
                   taskIds: group.taskIds,
-                  sampleReason: group.sampleReason,
+                  untrustedWorkerTextSample: group.untrustedWorkerTextSample,
                 },
               ],
             })),

package/src/be/swarm-config-guard.ts

@@ -1,6 +1,7 @@
 import { normalizeSlackReactionShortcode } from "../slack/reaction-shortcode";
 import { ProviderNameSchema } from "../types";
 import { parseTaskToolManifest } from "../utils/task-tool-manifest";
+import { isTierConfigKey, validateTierConfigValue } from "./model-tier-keys";
 
 /**
  * Guards against storing reserved keys in the swarm_config table.
@@ -274,6 +275,7 @@ const VALIDATED_KEYS: Record<string, ConfigValidator> = {
     return null;
   },
   ...booleanValidators([
+    "SWARM_DEV_MODE",
     "MULTI_RUNTIME_ENABLED",
     "STEERING_ENABLED",
     "MEMORY_HYBRID_SEARCH",
@@ -304,6 +306,7 @@ const VALIDATED_KEYS: Record<string, ConfigValidator> = {
     "SWARM_HIDE_CLOUD_PROMO",
     "DB_QUERY_BOUNDED_ENABLED",
     "DB_RETENTION_DRY_RUN",
+    "MODEL_AUTO_UPGRADE",
   ]),
   ...enumValidator("SLACK_MODE", ["socket", "http"]),
   ...enumValidator("SLACK_THREAD_STEERING", ["off", "lead", "all"]),
@@ -359,6 +362,8 @@ const VALIDATED_KEYS: Record<string, ConfigValidator> = {
   ),
   // 0 is meaningful here: "auto-assign nothing this sweep".
   ...integerValidators(["HEARTBEAT_MAX_AUTO_ASSIGN"], 0),
+  // 0 disables the `latest:...@stable` soak window.
+  ...integerValidators(["MODEL_LATEST_SOAK_DAYS"], 0),
   // 0 turns approval auto-cancellation off.
   ...integerValidators(["APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS"], 0),
   // Below ~100 tokens the preamble can't fit a useful summary; above 20000
@@ -378,6 +383,7 @@ const VALIDATED_KEYS: Record<string, ConfigValidator> = {
 };
 
 export function validateConfigValue(key: string, value: unknown): string | null {
+  if (isTierConfigKey(key)) return validateTierConfigValue(key.toUpperCase(), value);
   const validator = VALIDATED_KEYS[key.toUpperCase()];
   return validator ? validator(value) : null;
 }

package/src/cli.tsx

@@ -717,6 +717,16 @@ if (args.showHelp || args.command === "help" || args.command === undefined) {
 } else if (args.command === "version") {
   console.log(`${binName} v${pkg.version}`);
   process.exit(0);
+} else if (args.command === "onboard" && !process.versions.bun) {
+  // The published bin uses Node, but the onboarding wizard requires Bun APIs.
+  const { spawnSync } = await import("node:child_process");
+  const result = spawnSync("bun", process.argv.slice(1), { stdio: "inherit" });
+  if (result.error) {
+    console.error(
+      "Onboarding requires Bun. Install Bun from https://bun.sh, then retry this command.",
+    );
+  }
+  process.exit(result.status ?? 1);
 } else if (args.command === "docs") {
   const docsUrl = "https://docs.agent-swarm.dev";
   console.log(`\n${binName} docs — v${pkg.version}\n`);

package/src/commands/claude-managed-setup.ts

@@ -34,6 +34,7 @@ import type { SkillCreateResponse } from "@anthropic-ai/sdk/resources/beta/skill
 import { toFile } from "@anthropic-ai/sdk/uploads";
 
 import { buildSkillContent, type SkillTemplateConfig } from "../be/seed-skills/render";
+import { DEFAULT_MODEL_TIER_MAP } from "../types";
 import { getApiKey } from "../utils/api-key";
 import { promptHiddenInput } from "./codex-login.js";
 
@@ -65,7 +66,8 @@ export type ClaudeManagedSetupResult = {
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
-const DEFAULT_AGENT_MODEL = "claude-sonnet-5";
+/** The claude-managed `regular` tier default — no per-model constant here. */
+const DEFAULT_AGENT_MODEL = DEFAULT_MODEL_TIER_MAP["claude-managed"].regular;
 const SKILLS_DIR_RELATIVE = "plugin/commands";
 const SEEDED_SKILLS_DIR_RELATIVE = "templates/skills";
 const SKILLS_BETA_HEADER = "skills-2025-10-02";