@desplega.ai/agent-swarm 1.92.2 → 1.94.0

package/src/tests/migration-046-budgets.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, getDb, initDb } from "../be/db";
+import { seedPricingFromModelsDev } from "../be/seed-pricing";
 import { CODEX_MODEL_PRICING } from "../providers/codex-models";
 
 const TEST_DB_PATH = "./test-migration-046.sqlite";
@@ -173,6 +174,38 @@ describe("migration 046 — budgets and pricing", () => {
     }
   });
 
+  test("models.dev seed includes Claude Mythos 5 pricing rows", () => {
+    const db = getDb();
+    const result = seedPricingFromModelsDev({ quiet: true });
+    expect(result.modelsdevFound).toBe(true);
+
+    const expectedPrices = {
+      input: 10,
+      cached_input: 1,
+      cache_write: 12.5,
+      output: 50,
+    } as const;
+    const seededKeys = [
+      ["claude", "claude-mythos-5"],
+      ["claude-managed", "claude-mythos-5"],
+      ["claude", "mythos"],
+      ["claude-managed", "mythos"],
+      ["pi", "mythos"],
+    ] as const;
+
+    for (const [provider, model] of seededKeys) {
+      for (const [tokenClass, price] of Object.entries(expectedPrices)) {
+        const row = db
+          .prepare<PricingRow, [string, string, string]>(
+            `SELECT * FROM pricing
+             WHERE provider = ? AND model = ? AND token_class = ? AND effective_from = 0`,
+          )
+          .get(provider, model, tokenClass);
+        expect(row?.price_per_million_usd).toBe(price);
+      }
+    }
+  });
+
   test("idx_pricing_lookup index exists", () => {
     const db = getDb();
     const idx = db

package/src/tests/migration-runner-regressions.test.ts

@@ -2,9 +2,11 @@ import { Database } from "bun:sqlite";
 import { afterEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
+import { runMigrations } from "../be/migrations/runner";
 
 const INCOMPLETE_DB_PATH = "./test-migration-incomplete.sqlite";
 const FRESH_DB_PATH = "./test-migration-fresh.sqlite";
+const REPAIR_DB_PATH = "./test-migration-repair.sqlite";
 
 async function removeDbFiles(dbPath: string): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {
@@ -22,6 +24,7 @@ afterEach(async () => {
   closeDb();
   await removeDbFiles(INCOMPLETE_DB_PATH);
   await removeDbFiles(FRESH_DB_PATH);
+  await removeDbFiles(REPAIR_DB_PATH);
 });
 
 describe("migration regressions", () => {
@@ -98,4 +101,70 @@ describe("migration regressions", () => {
     expect(requestedByFk?.table).toBe("users");
     expect(requestedByFk?.to).toBe("id");
   });
+
+  test("repairs seed-as-090 history so 090_model_tiers is never skipped", () => {
+    // 2026-06-10 incident: PR #722 shipped the metrics seed as migration 090
+    // and production applied it; PR #719 then renumbered the seed to 091 and
+    // took 090 for model tiers. The runner keys applied migrations on version,
+    // so those databases skipped 090_model_tiers and crashed on the missing
+    // modelTier column. repairRenumberedModelTiers() in the runner must detect
+    // that history and fix it on boot.
+    const SEED_NAME = "090_seed_swarm_operations_metrics";
+    const SEED_CHECKSUM = "8ca4a05263b42d115b419f468bf5113caa5b7ee4363177568897513549224b01";
+
+    // Raw Database + runMigrations directly: initDb()'s test-template fast
+    // path skips the runner entirely, and the repair lives in the runner.
+    const database = new Database(REPAIR_DB_PATH, { create: true });
+    runMigrations(database);
+
+    // Reconstruct the divergent history: modelTier columns absent, version 90
+    // recorded as the seed migration.
+    database.run("ALTER TABLE agent_tasks DROP COLUMN modelTier");
+    database.run("ALTER TABLE scheduled_tasks DROP COLUMN modelTier");
+    database.run("UPDATE _migrations SET name = ?, checksum = ? WHERE version = 90", [
+      SEED_NAME,
+      SEED_CHECKSUM,
+    ]);
+
+    // Next boot repairs the history.
+    runMigrations(database);
+
+    for (const table of ["agent_tasks", "scheduled_tasks"]) {
+      const columns = database
+        .prepare<{ name: string }, []>(`PRAGMA table_info(${table})`)
+        .all()
+        .map((column) => column.name);
+      expect(columns).toContain("modelTier");
+    }
+
+    const row = database
+      .prepare<{ name: string; checksum: string }, []>(
+        "SELECT name, checksum FROM _migrations WHERE version = 90",
+      )
+      .get();
+    expect(row?.name).toBe("090_model_tiers");
+    expect(row?.checksum).not.toBe(SEED_CHECKSUM);
+
+    // The original failure mode: inserting a task with a modelTier value.
+    const now = new Date().toISOString();
+    expect(() => {
+      database.run(
+        `INSERT INTO agent_tasks (id, task, status, source, modelTier, createdAt, lastUpdatedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [crypto.randomUUID(), "boot triage", "pending", "system", "regular", now, now],
+      );
+    }).not.toThrow();
+
+    // Healthy histories are untouched: booting again is a no-op.
+    runMigrations(database);
+    const rowAfter = database
+      .prepare<{ name: string; checksum: string }, []>(
+        "SELECT name, checksum FROM _migrations WHERE version = 90",
+      )
+      .get();
+    expect(rowAfter?.name).toBe("090_model_tiers");
+    expect(rowAfter?.checksum).toBe(row?.checksum);
+
+    database.close();
+  });
 });

package/src/tests/model-control.test.ts

@@ -12,7 +12,17 @@ import {
   updateScheduledTask,
   upsertSwarmConfig,
 } from "../be/db";
+import {
+  parseModelTier,
+  resolveModelTier,
+  resolveTaskModelSelection,
+  splitLegacyModelAlias,
+} from "../model-tiers";
 import { runScheduleNow } from "../scheduler";
+import { createScheduleInputSchema } from "../tools/schedules/create-schedule";
+import { updateScheduleInputSchema } from "../tools/schedules/update-schedule";
+import { sendTaskInputSchema } from "../tools/send-task";
+import { taskActionInputSchema } from "../tools/task-action";
 
 const TEST_DB_PATH = "./test-model-control.sqlite";
 
@@ -84,6 +94,24 @@ describe("Model Control - Task Creation", () => {
     expect(task.model).toBe("sonnet");
     expect(task.status).toBe("offered");
   });
+
+  test("should store modelTier when creating a task with portable tier", () => {
+    const task = createTaskExtended("Test task with tier", { modelTier: "smart" });
+    expect(task.model).toBeUndefined();
+    expect(task.modelTier).toBe("smart");
+
+    const retrieved = getTaskById(task.id);
+    expect(retrieved?.modelTier).toBe("smart");
+  });
+
+  test("should preserve freeform concrete model strings", () => {
+    const task = createTaskExtended("Test task with freeform model", {
+      model: "openrouter/anthropic/claude-sonnet-4.6",
+    });
+
+    expect(task.model).toBe("openrouter/anthropic/claude-sonnet-4.6");
+    expect(task.modelTier).toBeUndefined();
+  });
 });
 
 describe("Model Control - Schedule Creation", () => {
@@ -102,7 +130,7 @@ describe("Model Control - Schedule Creation", () => {
   });
 
   test("should store all valid model values on schedules", () => {
-    for (const model of ["haiku", "sonnet", "opus"] as const) {
+    for (const model of ["haiku", "sonnet", "opus", "fable", "gpt-5.5"] as const) {
       const schedule = createScheduledTask({
         name: `model-schedule-all-${model}-${Date.now()}`,
         intervalMs: 60000,
@@ -123,6 +151,21 @@ describe("Model Control - Schedule Creation", () => {
 
     expect(schedule.model).toBeUndefined();
   });
+
+  test("should store modelTier on scheduled task creation", () => {
+    const schedule = createScheduledTask({
+      name: "model-schedule-tier",
+      intervalMs: 60000,
+      taskTemplate: "Scheduled with portable tier",
+      modelTier: "regular",
+    });
+
+    expect(schedule.model).toBeUndefined();
+    expect(schedule.modelTier).toBe("regular");
+
+    const retrieved = getScheduledTaskById(schedule.id);
+    expect(retrieved?.modelTier).toBe("regular");
+  });
 });
 
 describe("Model Control - Schedule Update", () => {
@@ -169,6 +212,23 @@ describe("Model Control - Schedule Update", () => {
     expect(updated?.model).toBe("haiku");
     expect(updated?.priority).toBe(90);
   });
+
+  test("should update and clear modelTier on existing schedule", () => {
+    const schedule = createScheduledTask({
+      name: "model-tier-update-test",
+      intervalMs: 60000,
+      taskTemplate: "Update model tier test",
+      modelTier: "regular",
+    });
+
+    expect(schedule.modelTier).toBe("regular");
+
+    const updated = updateScheduledTask(schedule.id, { modelTier: "ultra" });
+    expect(updated?.modelTier).toBe("ultra");
+
+    const cleared = updateScheduledTask(schedule.id, { modelTier: null });
+    expect(cleared?.modelTier).toBeUndefined();
+  });
 });
 
 describe("Model Control - Schedule to Task Propagation", () => {
@@ -213,6 +273,28 @@ describe("Model Control - Schedule to Task Propagation", () => {
     const task = getTaskById(row!.id);
     expect(task?.model).toBeUndefined();
   });
+
+  test("should propagate modelTier from schedule to task on manual run", async () => {
+    const schedule = createScheduledTask({
+      name: "model-tier-propagate-manual",
+      intervalMs: 60000,
+      taskTemplate: "Propagated model tier task (manual)",
+      modelTier: "smart",
+      enabled: true,
+    });
+
+    await runScheduleNow(schedule.id);
+
+    const { getDb } = await import("../be/db");
+    const row = getDb()
+      .query("SELECT id FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1")
+      .get("Propagated model tier task (manual)") as { id: string } | null;
+
+    expect(row).not.toBeNull();
+    const task = getTaskById(row!.id);
+    expect(task?.model).toBeUndefined();
+    expect(task?.modelTier).toBe("smart");
+  });
 });
 
 describe("Model Control - Config MODEL_OVERRIDE Resolution", () => {
@@ -268,71 +350,105 @@ describe("Model Control - Config MODEL_OVERRIDE Resolution", () => {
 });
 
 describe("Model Control - Priority Resolution Logic", () => {
-  // The runner resolves model as: task.model || freshEnv.MODEL_OVERRIDE || "opus"
-  // We test the same logic pattern here to ensure correctness
-
-  function resolveModel(taskModel?: string, configOverride?: string): string {
-    return taskModel || configOverride || "opus";
-  }
-
   test("task.model takes highest priority", () => {
-    expect(resolveModel("haiku", "sonnet")).toBe("haiku");
+    expect(
+      resolveTaskModelSelection({
+        model: "gpt-5.5",
+        modelTier: "smol",
+        harnessProvider: "codex",
+      }).model,
+    ).toBe("gpt-5.5");
   });
 
-  test("config MODEL_OVERRIDE is used when task has no model", () => {
-    expect(resolveModel(undefined, "sonnet")).toBe("sonnet");
+  test("task.modelTier resolves using the claiming worker harness", () => {
+    expect(resolveModelTier({ tier: "smol", harnessProvider: "claude" })).toBe("haiku");
+    expect(resolveModelTier({ tier: "smol", harnessProvider: "codex" })).toBe("gpt-5.4-mini");
+    expect(resolveModelTier({ tier: "smart", harnessProvider: "opencode" })).toBe(
+      "openrouter/deepseek/deepseek-v4-pro",
+    );
+    expect(resolveModelTier({ tier: "ultra", harnessProvider: "pi" })).toBe(
+      "openrouter/anthropic/claude-opus-4.8",
+    );
   });
 
-  test("defaults to 'opus' when no task model and no config override", () => {
-    expect(resolveModel(undefined, undefined)).toBe("opus");
+  test("task.modelTier supports env map and direct tier overrides", () => {
+    expect(
+      resolveModelTier({
+        tier: "regular",
+        harnessProvider: "codex",
+        env: { MODEL_TIER_MAP: JSON.stringify({ regular: "gpt-5.3-codex" }) },
+      }),
+    ).toBe("gpt-5.3-codex");
+    expect(
+      resolveModelTier({
+        tier: "regular",
+        harnessProvider: "codex",
+        env: {
+          MODEL_TIER_MAP: JSON.stringify({ regular: "gpt-5.3-codex" }),
+          MODEL_TIER_REGULAR: "gpt-5.5",
+        },
+      }),
+    ).toBe("gpt-5.5");
   });
 
-  test("empty string task model falls through to config", () => {
-    expect(resolveModel("", "sonnet")).toBe("sonnet");
+  test("legacy model aliases parse as tiers", () => {
+    expect(parseModelTier("haiku")).toBe("smol");
+    expect(parseModelTier("sonnet")).toBe("regular");
+    expect(parseModelTier("opus")).toBe("smart");
+    expect(parseModelTier("fable")).toBe("ultra");
+    expect(splitLegacyModelAlias({ model: "opus" })).toEqual({ modelTier: "smart" });
   });
 
-  test("empty string config override falls through to default", () => {
-    expect(resolveModel(undefined, "")).toBe("opus");
+  test("freeform concrete model strings stay concrete", () => {
+    expect(splitLegacyModelAlias({ model: "gpt-5.5" })).toEqual({
+      model: "gpt-5.5",
+      modelTier: undefined,
+    });
   });
 
-  test("all three levels specified — task wins", () => {
-    expect(resolveModel("haiku", "sonnet")).toBe("haiku");
-    // "opus" is the hardcoded default, tested implicitly
+  test("missing task model selection falls through to adapter/config", () => {
+    expect(
+      resolveTaskModelSelection({ model: "", modelTier: undefined, harnessProvider: "codex" }),
+    ).toEqual({ source: "none" });
   });
 });
 
 describe("Model Control - Zod Validation Schema", () => {
-  // The MCP tools use z.enum(["haiku", "sonnet", "opus"]) for validation.
-  // We test the schema directly to ensure only valid values are accepted.
-
-  test("should accept valid model values", async () => {
-    const { z } = await import("zod");
-    const modelSchema = z.enum(["haiku", "sonnet", "opus"]).optional();
-
-    expect(modelSchema.parse("haiku")).toBe("haiku");
-    expect(modelSchema.parse("sonnet")).toBe("sonnet");
-    expect(modelSchema.parse("opus")).toBe("opus");
-    expect(modelSchema.parse(undefined)).toBeUndefined();
+  test("task tools accept freeform concrete models and model tiers", () => {
+    expect(
+      sendTaskInputSchema.parse({ agentId: crypto.randomUUID(), task: "x", model: "gpt-5.5" })
+        .model,
+    ).toBe("gpt-5.5");
+    expect(
+      taskActionInputSchema.parse({ action: "create", task: "x", modelTier: "ultra" }).modelTier,
+    ).toBe("ultra");
   });
 
-  test("should reject invalid model values", async () => {
-    const { z } = await import("zod");
-    const modelSchema = z.enum(["haiku", "sonnet", "opus"]).optional();
-
-    expect(() => modelSchema.parse("gpt-4")).toThrow();
-    expect(() => modelSchema.parse("claude")).toThrow();
-    expect(() => modelSchema.parse("turbo")).toThrow();
-    expect(() => modelSchema.parse("")).toThrow();
-    expect(() => modelSchema.parse(123)).toThrow();
-    expect(() => modelSchema.parse(null)).toThrow();
+  test("task tools reject empty model strings and invalid tiers", () => {
+    expect(() =>
+      sendTaskInputSchema.parse({ agentId: crypto.randomUUID(), task: "x", model: "" }),
+    ).toThrow();
+    expect(() =>
+      taskActionInputSchema.parse({ action: "create", task: "x", modelTier: "massive" }),
+    ).toThrow();
   });
 
   test("nullable model schema (update-schedule) should accept null", async () => {
-    const { z } = await import("zod");
-    const modelSchema = z.enum(["haiku", "sonnet", "opus"]).nullable().optional();
+    expect(updateScheduleInputSchema.shape.model.parse(null)).toBeNull();
+    expect(updateScheduleInputSchema.shape.model.parse("gpt-5.5")).toBe("gpt-5.5");
+    expect(updateScheduleInputSchema.shape.modelTier.parse(null)).toBeNull();
+    expect(updateScheduleInputSchema.shape.modelTier.parse("smol")).toBe("smol");
+  });
 
-    expect(modelSchema.parse(null)).toBeNull();
-    expect(modelSchema.parse("haiku")).toBe("haiku");
-    expect(modelSchema.parse(undefined)).toBeUndefined();
+  test("create schedule schema accepts freeform model and modelTier", () => {
+    const parsed = createScheduleInputSchema.parse({
+      name: "schema-model-tier",
+      taskTemplate: "x",
+      intervalMs: 60000,
+      model: "openrouter/openai/gpt-5.5",
+      modelTier: "smart",
+    });
+    expect(parsed.model).toBe("openrouter/openai/gpt-5.5");
+    expect(parsed.modelTier).toBe("smart");
   });
 });

package/src/tests/opencode-adapter.test.ts

@@ -156,6 +156,15 @@ describe("OpencodeSession — SSE→ProviderEvent mapping", () => {
     ];
     const { emitted, result, serverCloseCalls } = await driveSession(events);
 
+    const sessionInit = emitted.find((e) => e.type === "session_init");
+    expect(sessionInit).toBeDefined();
+    if (sessionInit?.type === "session_init") {
+      expect(sessionInit.provider).toBe("opencode");
+      expect(sessionInit.harnessVariant).toBe("stock");
+      expect(typeof sessionInit.harnessVariantMeta?.version).toBe("string");
+      expect((sessionInit.harnessVariantMeta?.version as string).length).toBeGreaterThan(0);
+    }
+
     const resultEvent = emitted.find((e) => e.type === "result");
     expect(resultEvent).toBeDefined();
     if (resultEvent?.type === "result") {