@desplega.ai/agent-swarm 1.173.0 → 2.1.0

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

@@ -3,7 +3,7 @@ import { unlink } from "node:fs/promises";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { Readable } from "node:stream";
 import { createApp } from "../apps/store";
-import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
+import { closeDb, createAgent, getDbClient, initDb, upsertSwarmConfig } from "../be/db";
 import { getScript, listScripts } from "../be/scripts/db";
 import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
 import { configSecretName, registerStoredSecret } from "../be/secret-registry";
@@ -16,6 +16,7 @@ import {
 } from "../utils/secret-scrubber";
 import { SKIP_SANDBOX_SPAWN_TESTS } from "./sandbox-spawn-test-helpers";
 import { randomToken } from "./synthetic-secret-helpers";
+import { CHILD_PROCESS_TEST_BUDGET_MS } from "./test-proc";
 
 const skip = test.skipIf(SKIP_SANDBOX_SPAWN_TESTS);
 
@@ -241,6 +242,22 @@ describe("/api/scripts HTTP", () => {
     expect(await second.json()).toEqual({ name: "double", version: 2, contentDeduped: false });
   });
 
+  test("upsert saves a quickjs-incompatible script and returns advisory warnings", async () => {
+    const res = await upsert({
+      name: "uses-process",
+      // The script typings omit process, but a cast still typechecks.
+      source:
+        "export default async (): Promise<string> => (globalThis as any).process.env.HOME ?? '';",
+    });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      name: "uses-process",
+      version: 1,
+      contentDeduped: false,
+      warnings: ["quickjs compat (process, line 1): process is not available under quickjs"],
+    });
+  });
+
   test("upsert typecheck failures return diagnostics and do not write rows", async () => {
     const res = await upsert({
       name: "bad-types",
@@ -737,3 +754,202 @@ describe("script source with an embedded secret is refused at write", () => {
     expect(response.status).toBe(200);
   });
 });
+
+// Regression: ctx.swarm.config.get used to return undefined for every key,
+// because no run entry point filled the payload's user config. These go
+// through the real POST /api/scripts/run route, not an injected payload.
+describe("ctx.swarm.config.get through POST /api/scripts/run", () => {
+  const secretValue = `cfg-secret-${randomToken(32)}`;
+  // Under the global scrubber's 12-char floor, so only the run's own
+  // output boundary can redact it.
+  const shortSecretValue = randomToken(10);
+  const readerSource = `
+    import type { ScriptContext } from "swarm-sdk";
+    export default async (_args: unknown, ctx: ScriptContext) => {
+      const read = (key: string) => {
+        const value = ctx.swarm.config.get(key);
+        return value === undefined ? null : ctx.stdlib.Redacted.value(value);
+      };
+      const secret = ctx.swarm.config.get("SCRIPT_CFG_SECRET");
+      console.log("secret:", secret === undefined ? "missing" : ctx.stdlib.Redacted.value(secret));
+      return {
+        plain: read("SCRIPT_CFG_PLAIN"),
+        override: read("SCRIPT_CFG_OVERRIDE"),
+        // Compare by shape: the literal value in source would be refused at write.
+        secretMatches:
+          secret !== undefined &&
+          ctx.stdlib.Redacted.value(secret).startsWith("cfg-secret-") &&
+          ctx.stdlib.Redacted.value(secret).length === ${secretValue.length},
+        secretIsSecret: secret !== undefined && ctx.stdlib.Redacted.isSecret(secret),
+        secretStringified: String(secret),
+        missingIsUndefined: ctx.swarm.config.get("SCRIPT_CFG_NOT_SET") === undefined,
+        fallback: read("SCRIPT_CFG_NOT_SET") ?? "fallback",
+        apiOnly: read("SLACK_SIGNING_SECRET"),
+        proto: read("__proto__"),
+      };
+    };`;
+
+  type Reader = {
+    plain: string | null;
+    override: string | null;
+    secretMatches: boolean;
+    secretIsSecret: boolean;
+    secretStringified: string;
+    missingIsUndefined: boolean;
+    fallback: string;
+    apiOnly: string | null;
+    proto: string | null;
+  };
+
+  beforeAll(async () => {
+    await upsertSwarmConfig({ scope: "global", key: "SCRIPT_CFG_PLAIN", value: "plain-global" });
+    await upsertSwarmConfig({ scope: "global", key: "SCRIPT_CFG_OVERRIDE", value: "from-global" });
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: workerId,
+      key: "SCRIPT_CFG_OVERRIDE",
+      value: "from-worker",
+    });
+    await upsertSwarmConfig({
+      scope: "global",
+      key: "SCRIPT_CFG_SECRET",
+      value: secretValue,
+      isSecret: true,
+    });
+    await upsertSwarmConfig({
+      scope: "global",
+      key: "SCRIPT_CFG_SHORT_SECRET",
+      value: shortSecretValue,
+      isSecret: true,
+    });
+    await upsertSwarmConfig({ scope: "global", key: "__proto__", value: "proto-global" });
+    await upsertSwarmConfig({
+      scope: "global",
+      key: "SLACK_SIGNING_SECRET",
+      value: `signing-${randomToken(24)}`,
+      isSecret: true,
+    });
+  });
+
+  afterAll(async () => {
+    await getDbClient().run(
+      "DELETE FROM swarm_config WHERE key LIKE 'SCRIPT_CFG_%' OR key IN ('SLACK_SIGNING_SECRET', '__proto__')",
+    );
+    clearVolatileSecretsForTesting();
+  });
+
+  async function run(body: Record<string, unknown>, agentId: string) {
+    const response = await dispatch("/api/scripts/run", {
+      method: "POST",
+      agentId,
+      body: JSON.stringify(body),
+    });
+    expect(response.status).toBe(200);
+    return (await response.json()) as { result: Reader; stdout: string; error?: string };
+  }
+
+  skip(
+    "inline run reads existing keys, agent scope over global, and undefined for a missing key",
+    async () => {
+      const out = await run({ source: readerSource, intent: "config get regression" }, workerId);
+      expect(out.error).toBeUndefined();
+      expect(out.result).toEqual({
+        plain: "plain-global",
+        override: "from-worker",
+        secretMatches: true,
+        secretIsSecret: true,
+        secretStringified: "<redacted>",
+        missingIsUndefined: true,
+        fallback: "fallback",
+        apiOnly: null,
+        proto: "proto-global",
+      });
+      // The unwrapped secret is scrubbed from everything the run returns.
+      expect(out.stdout).toContain("secret:");
+      expect(JSON.stringify(out)).not.toContain(secretValue);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  skip(
+    "named run resolves config for the invoking agent",
+    async () => {
+      expect((await upsert({ name: "config-reader", source: readerSource }, leadId)).status).toBe(
+        200,
+      );
+      const out = await run({ name: "config-reader" }, leadId);
+      expect(out.error).toBeUndefined();
+      // The worker's agent-scope override does not leak to another agent.
+      expect(out.result.override).toBe("from-global");
+      expect(out.result.plain).toBe("plain-global");
+      expect(out.result.secretMatches).toBe(true);
+      expect(out.result.missingIsUndefined).toBe(true);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  skip(
+    "a short secret the run read stays out of stdout, result and the stored run row",
+    async () => {
+      // No `secret:` label in the log line: that prefix triggers structural
+      // masking and would hide a missing value-level redaction.
+      const source = `
+      import type { ScriptContext } from "swarm-sdk";
+      export default async (_args: unknown, ctx: ScriptContext) => {
+        const raw = ctx.stdlib.Redacted.value(ctx.swarm.config.get("SCRIPT_CFG_SHORT_SECRET")!);
+        console.log("read:", raw);
+        return { leaked: raw, length: raw.length, [raw]: "as-key" };
+      };`;
+      const response = await dispatch("/api/scripts/run", {
+        method: "POST",
+        agentId: workerId,
+        body: JSON.stringify({ source, intent: "short config secret redaction" }),
+      });
+      expect(response.status).toBe(200);
+      const out = (await response.json()) as {
+        result: Record<string, unknown>;
+        stdout: string;
+        error?: string;
+      };
+      expect(out.error).toBeUndefined();
+      // The script really read the value: only its rendering is redacted.
+      expect(out.result.length).toBe(shortSecretValue.length);
+      expect(out.stdout).toContain("read: [REDACTED:config:SCRIPT_CFG_SHORT_SECRET]");
+      expect(out.stdout).not.toContain(shortSecretValue);
+      expect(out.result.leaked).toBe("[REDACTED:config:SCRIPT_CFG_SHORT_SECRET]");
+      expect(JSON.stringify(out.result)).not.toContain(shortSecretValue);
+
+      const row = await getDbClient().get<{ output: string | null }>(
+        "SELECT output FROM script_runs WHERE agentId = ? AND source = ?",
+        [workerId, source],
+      );
+      expect(row?.output).toBeTruthy();
+      expect(row?.output).toContain("[REDACTED:config:SCRIPT_CFG_SHORT_SECRET]");
+      expect(row?.output).not.toContain(shortSecretValue);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test("an import rejection quoting a short secret stays out of stderr and the stored run row", async () => {
+    // The import check returns before any process spawns, so its diagnostic
+    // needs the run-local scrub too.
+    const source = `import nope from "${shortSecretValue}"; export default async () => nope;`;
+    const response = await dispatch("/api/scripts/run", {
+      method: "POST",
+      agentId: workerId,
+      body: JSON.stringify({ source, intent: "short config secret in import diagnostic" }),
+    });
+    expect(response.status).toBe(200);
+    const out = (await response.json()) as { stderr: string; error?: string };
+    expect(out.error).toBe("import_violation");
+    expect(out.stderr).toContain("[REDACTED:config:SCRIPT_CFG_SHORT_SECRET]");
+    expect(out.stderr).not.toContain(shortSecretValue);
+
+    const row = await getDbClient().get<{ error: string | null }>(
+      "SELECT error FROM script_runs WHERE agentId = ? AND source = ?",
+      [workerId, source],
+    );
+    expect(row?.error).toBeTruthy();
+    expect(row?.error).not.toContain(shortSecretValue);
+  });
+});

package/src/tests/scripts-only-gating.test.ts

@@ -10,7 +10,7 @@ import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/se
 import { closeDb, createAgent, getDbClient, initDb, upsertSwarmConfig } from "../be/db";
 import { _resetAutoReloadForTests, flushPendingIntegrationsReload } from "../http/core";
 import { handleMcp } from "../http/mcp";
-import { getBasePrompt } from "../prompts/base-prompt";
+import { getBasePrompt, getTaskContextPrompt } from "../prompts/base-prompt";
 import { createServer } from "../server";
 import { resolveScriptsOnlyMode } from "../utils/scripts-only-mode";
 import { listenOnFreePort } from "./test-net";
@@ -371,9 +371,8 @@ describe("scripts-only prompt gating", () => {
   });
 
   test("uses the scripts-only Slack variant for Slack-originated tasks", async () => {
-    const prompt = await getBasePrompt({
+    const prompt = await getTaskContextPrompt({
       role: "worker",
-      agentId: "scripts-only-slack-agent",
       scriptsOnly: true,
       slackContext: { channelId: "C123", threadTs: "123.456" },
     });

package/src/tests/scripts-runtime.test.ts

@@ -96,54 +96,72 @@ describe("runScript", () => {
     expect(output.result).toEqual({ status: 200, parsed: { ok: true } });
   });
 
-  spawnTest("ctx.swarm bridge round-trips kv_set then kv_get", async () => {
-    const entries = new Map<string, unknown>();
-    const server = Bun.serve({
-      port: 0,
-      async fetch(req) {
-        expect(req.headers.get("authorization")).toBe(
-          "Bearer example-runtime-test-secret-1234567890",
-        );
-        expect(req.headers.get("x-agent-id")).toBe("agent-1");
+  spawnTest(
+    "ctx.swarm bridge respects URL overrides and PORT fallback",
+    async () => {
+      const entries = new Map<string, unknown>();
+      const agentId = crypto.randomUUID();
+      const server = Bun.serve({
+        hostname: "localhost",
+        port: 0,
+        async fetch(req) {
+          expect(req.headers.get("authorization")).toBe(
+            "Bearer example-runtime-test-secret-1234567890",
+          );
+          expect(req.headers.get("x-agent-id")).toBe(agentId);
+
+          const url = new URL(req.url);
+          if (req.method === "PUT" && url.pathname.startsWith("/api/kv/")) {
+            const key = decodeURIComponent(url.pathname.slice("/api/kv/".length));
+            const body = (await req.json()) as { value: unknown };
+            entries.set(key, body.value);
+            return Response.json({ key, value: body.value });
+          }
+          if (req.method === "GET" && url.pathname.startsWith("/api/kv/")) {
+            const key = decodeURIComponent(url.pathname.slice("/api/kv/".length));
+            return Response.json({ key, value: entries.get(key) ?? null });
+          }
+          return Response.json({ error: "not found" }, { status: 404 });
+        },
+      });
 
-        const url = new URL(req.url);
-        if (req.method === "PUT" && url.pathname.startsWith("/api/kv/")) {
-          const key = decodeURIComponent(url.pathname.slice("/api/kv/".length));
-          const body = (await req.json()) as { value: unknown };
-          entries.set(key, body.value);
-          return Response.json({ key, value: body.value });
-        }
-        if (req.method === "GET" && url.pathname.startsWith("/api/kv/")) {
-          const key = decodeURIComponent(url.pathname.slice("/api/kv/".length));
-          return Response.json({ key, value: entries.get(key) ?? null });
-        }
-        return Response.json({ error: "not found" }, { status: 404 });
-      },
-    });
+      try {
+        const baseUrl = `http://localhost:${server.port}`;
+        for (const urlSource of ["input", "MCP_BASE_URL", "PORT"] as const) {
+          delete process.env.PORT;
+          process.env.MCP_BASE_URL = "http://unused.invalid";
+          if (urlSource === "MCP_BASE_URL") {
+            process.env.MCP_BASE_URL = baseUrl;
+          } else if (urlSource === "PORT") {
+            delete process.env.MCP_BASE_URL;
+            process.env.PORT = String(server.port);
+          }
 
-    try {
-      const output = await runScript({
-        agentId: "agent-1",
-        mcpBaseUrl: `http://127.0.0.1:${server.port}`,
-        resources,
-        source: `
+          const output = await runScript({
+            agentId,
+            mcpBaseUrl: urlSource === "input" ? baseUrl : undefined,
+            resources,
+            source: `
           export default async (_args, ctx) => {
             await ctx.swarm.kv_set({ key: "bridge-smoke", value: { ok: true } });
             return await ctx.swarm.kv_get({ key: "bridge-smoke" });
           };
         `,
-      });
+          });
 
-      expect(output.error).toBeUndefined();
-      expect(output.result).toEqual({
-        success: true,
-        status: 200,
-        data: { key: "bridge-smoke", value: { ok: true } },
-      });
-    } finally {
-      server.stop(true);
-    }
-  });
+          expect(output.error, `${urlSource}: ${output.stderr}`).toBeUndefined();
+          expect(output.result, urlSource).toEqual({
+            success: true,
+            status: 200,
+            data: { key: "bridge-smoke", value: { ok: true } },
+          });
+        }
+      } finally {
+        server.stop(true);
+      }
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
 
   spawnTest("ctx.swarm.kv_get forwards path/offset/limit as a view query", async () => {
     const seen: string[] = [];

package/src/tests/secret-scrubber.test.ts

@@ -1,10 +1,14 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { openAICompatibleKeyVars } from "@desplega/model-catalog";
 import {
   clearVolatileSecretsForTesting,
+  createValueScrubber,
   isSensitiveKey,
   refreshSecretScrubberCache,
+  registerEnvSecrets,
   registerSensitiveKeyName,
   registerVolatileSecret,
+  SCRUBBER_RULES_VERSION,
   scrubObject,
   scrubSecrets,
   unregisterVolatileSecret,
@@ -77,6 +81,33 @@ describe("scrubSecrets — env-based replacement", () => {
     expect(out).toBe("key=[REDACTED:FOO_SERVICE_API_KEY] tail");
   });
 
+  test("redacts NaN and Helmcode keys, including the suffix-less HELMCODE_API_NAN alias", () => {
+    const values = {
+      NAN_API_KEY: `example-nan-${randomToken(24)}`,
+      HELMCODE_API_NAN: `example-nanalias-${randomToken(24)}`,
+      HELMCODE_API_KEY: `example-helm-${randomToken(24)}`,
+    };
+    for (const [name, value] of Object.entries(values)) process.env[name] = value;
+    refreshSecretScrubberCache();
+    for (const [name, value] of Object.entries(values)) {
+      expect(isSensitiveKey(name)).toBe(true);
+      expect(scrubSecrets(`Bearer ${value} tail`)).toBe(`Bearer [REDACTED:${name}] tail`);
+    }
+  });
+
+  test("the registry key vars are pinned to SCRUBBER_RULES_VERSION", () => {
+    // Every registry key var is an exact sensitive key, so a new registry
+    // entry changes the rules: bump SCRUBBER_RULES_VERSION (the boot sweep
+    // re-redacts stored rows once per version), then update this pin.
+    expect({
+      version: SCRUBBER_RULES_VERSION,
+      keyVars: [...openAICompatibleKeyVars()].sort(),
+    }).toEqual({
+      version: 8,
+      keyVars: ["AI_GATEWAY_API_KEY", "HELMCODE_API_KEY", "HELMCODE_API_NAN", "NAN_API_KEY"],
+    });
+  });
+
   test("redacts any key with _TOKEN suffix", () => {
     process.env.WEIRD_SERVICE_TOKEN = "example-weirdserviceTOKENvalue_1234567890";
     refreshSecretScrubberCache();
@@ -390,6 +421,33 @@ describe("registerVolatileSecret", () => {
     expect(out).not.toContain(secret);
   });
 
+  test("registerEnvSecrets covers a per-task env that never reached process.env", () => {
+    const picked = `opaque${randomToken(20)}`;
+    const member = `opaque${randomToken(20)}`;
+    const env = {
+      HELMCODE_API_KEY: picked,
+      HELMCODE_API_NAN: `${member},opaque${randomToken(20)}`,
+      HELMCODE_BASE_URL: "http://127.0.0.1:9/v1",
+    };
+    expect(process.env.HELMCODE_API_KEY).not.toBe(picked);
+    expect(scrubSecrets(`echo ${picked}`)).toContain(picked);
+    registerEnvSecrets(env);
+    expect(scrubSecrets(`echo ${picked}`)).toBe("echo [REDACTED:HELMCODE_API_KEY]");
+    expect(scrubSecrets(`echo ${member}`)).toBe("echo [REDACTED:HELMCODE_API_NAN]");
+    // A non-secret key stays readable.
+    expect(scrubSecrets("http://127.0.0.1:9/v1")).toBe("http://127.0.0.1:9/v1");
+  });
+
+  test("padded singleton values redact their trimmed form", () => {
+    const fromEnv = `opaque${randomToken(20)}`;
+    const fromMap = `opaque${randomToken(20)}`;
+    process.env.PADDED_API_KEY = `  ${fromEnv}\n`;
+    refreshSecretScrubberCache();
+    registerEnvSecrets({ HELMCODE_API_NAN: ` ${fromMap} ` });
+    expect(scrubSecrets(`key: ${fromEnv}`)).toBe("key: [REDACTED:PADDED_API_KEY]");
+    expect(scrubSecrets(`key: ${fromMap}`)).toBe("key: [REDACTED:HELMCODE_API_NAN]");
+  });
+
   test("ignores values shorter than the minimum length", () => {
     registerVolatileSecret("short", "TOO_SHORT");
     const out = scrubSecrets("contains short somewhere");
@@ -889,3 +947,41 @@ describe("scrubSecrets — over-redaction guards", () => {
     { retry: 2 },
   );
 });
+
+describe("createValueScrubber (per-run exact values)", () => {
+  test("redacts values under the global floor without registering them swarm-wide", () => {
+    const short = randomToken(5);
+    const scrub = createValueScrubber([{ value: short, name: "config:SHORT" }]);
+    expect(scrub.text(`got ${short}!`)).toBe("got [REDACTED:config:SHORT]!");
+    expect(scrubSecrets(`got ${short}!`)).toBe(`got ${short}!`);
+  });
+
+  test("a one-char value is redacted everywhere in the run's output", () => {
+    const scrub = createValueScrubber([{ value: "x", name: "config:ONE" }]);
+    expect(scrub.text("x+x")).toBe("[REDACTED:config:ONE]+[REDACTED:config:ONE]");
+  });
+
+  test("one pass, longest first: a marker is never rewritten by another value", () => {
+    const scrub = createValueScrubber([
+      { value: "RED", name: "config:A" },
+      { value: "REDACT", name: "config:B" },
+    ]);
+    expect(scrub.text("RED REDACT")).toBe("[REDACTED:config:A] [REDACTED:config:B]");
+  });
+
+  test("covers JSON-escaped forms, object keys and nested values", () => {
+    const value = 'a"b';
+    const scrub = createValueScrubber([{ value, name: "config:Q" }]);
+    expect(scrub.text(JSON.stringify({ v: value }))).toBe('{"v":"[REDACTED:config:Q]"}');
+    expect(scrub.object({ [value]: [value, 1, null] })).toEqual({
+      "[REDACTED:config:Q]": ["[REDACTED:config:Q]", 1, null],
+    });
+  });
+
+  test("no values and empty values are a no-op", () => {
+    const scrub = createValueScrubber([{ value: "", name: "config:EMPTY" }]);
+    expect(scrub.text("unchanged")).toBe("unchanged");
+    const obj = { a: 1 };
+    expect(scrub.object(obj)).toBe(obj);
+  });
+});

package/src/tests/seed-model-profiles.test.ts

@@ -0,0 +1,174 @@
+// The shipped `<harness>-<tier>` seeds, and migration 220's profiles made from
+// agents' MODEL_OVERRIDE + REASONING_EFFORT_OVERRIDE.
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  closeDb,
+  createAgent,
+  getDb,
+  getDbClient,
+  getSwarmConfigs,
+  initDb,
+  upsertSwarmConfig,
+} from "../be/db";
+import { getModelProfileByName, listModelProfiles } from "../be/db/model-profiles";
+import { recordClaimModelResolution } from "../be/model-tier-resolution";
+import { seedModelProfiles } from "../be/seed-model-profiles";
+import { DEFAULT_MODEL_TIER_MAP, type MODEL_TIERS, type ProviderName } from "../types";
+
+const TEST_DB_PATH = "./test-seed-model-profiles.sqlite";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+/** The part of migration 220 that turns agent overrides into profiles. */
+function agentOverrideMigrationSql(): string {
+  const sql = readFileSync(
+    join(import.meta.dir, "../be/migrations/220_model_profiles.sql"),
+    "utf8",
+  );
+  return sql.slice(sql.indexOf("CREATE TEMP TABLE _model_profile_overrides"));
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(async () => {
+  const client = getDbClient();
+  // References first: migration 220's triggers refuse deleting a named profile.
+  await client.run("DELETE FROM agent_tasks");
+  await client.run("DELETE FROM swarm_config");
+  await client.run("DELETE FROM swarm_repos");
+  await client.run("DELETE FROM agents");
+  await client.run("DELETE FROM model_profiles");
+});
+
+describe("tier seeds", () => {
+  test("one profile per harness and tier, copied from the tier map; none for acp", async () => {
+    expect(await seedModelProfiles()).toBe(40);
+    const profiles = await listModelProfiles();
+    expect(profiles).toHaveLength(40);
+    expect(profiles.some((p) => p.harness === "acp")).toBe(false);
+    for (const profile of profiles) {
+      const tier = profile.seededFrom?.replace("tier:", "") as (typeof MODEL_TIERS)[number];
+      expect(profile.name).toBe(`${profile.harness}-${tier}`);
+      expect(profile.model).toBe(DEFAULT_MODEL_TIER_MAP[profile.harness as ProviderName][tier]);
+      expect(profile.effort).toBeNull();
+    }
+    expect((await getModelProfileByName("claude-smart"))?.model).toBe("opus");
+    expect((await getModelProfileByName("codex-ultra"))?.model).toBe("gpt-5.6-sol");
+  });
+
+  test("a global MODEL_TIER row overrides the seed's model; reseeding never overwrites", async () => {
+    await upsertSwarmConfig({
+      scope: "global",
+      key: "MODEL_TIER_CLAUDE_SMART",
+      value: "claude-opus-5-5",
+    });
+    await seedModelProfiles();
+    expect((await getModelProfileByName("claude-smart"))?.model).toBe("claude-opus-5-5");
+
+    await getDbClient().run(
+      "UPDATE model_profiles SET model = 'edited' WHERE name = 'claude-regular'",
+    );
+    expect(await seedModelProfiles()).toBe(0);
+    expect((await getModelProfileByName("claude-regular"))?.model).toBe("edited");
+  });
+});
+
+describe("migration 220: profiles from agent overrides", () => {
+  async function agentWith(
+    name: string,
+    harnessProvider: ProviderName,
+    model?: string,
+    effort?: string,
+  ): Promise<string> {
+    const agent = await createAgent({ name, isLead: false, status: "idle", harnessProvider });
+    if (model) {
+      await upsertSwarmConfig({
+        scope: "agent",
+        scopeId: agent.id,
+        key: "MODEL_OVERRIDE",
+        value: model,
+      });
+    }
+    if (effort) {
+      await upsertSwarmConfig({
+        scope: "agent",
+        scopeId: agent.id,
+        key: "REASONING_EFFORT_OVERRIDE",
+        value: effort,
+      });
+    }
+    return agent.id;
+  }
+
+  test("dedupes by (harness, model, effort) and makes each the agent's default", async () => {
+    const a = await agentWith("m-a", "claude", "claude-opus-5-5", "high");
+    const b = await agentWith("m-b", "claude", "claude-opus-5-5", "high");
+    const c = await agentWith("m-c", "codex", "gpt-6.1-sol", "xhigh");
+    const d = await agentWith("m-d", "claude", "openrouter/vendor/model:free");
+    const skipped = [
+      await agentWith("m-acp", "acp", "some-acp-model"),
+      await agentWith("m-alias", "claude", "latest:anthropic/opus"),
+      await agentWith("m-none", "claude"),
+    ];
+
+    getDb().exec(agentOverrideMigrationSql());
+
+    const profiles = await listModelProfiles();
+    expect(profiles.map((p) => [p.name, p.harness, p.model, p.effort])).toEqual([
+      ["claude-openrouter-vendor-model-free", "claude", "openrouter/vendor/model:free", null],
+      ["claude-opus-5-5-high", "claude", "claude-opus-5-5", "high"],
+      ["codex-gpt-6.1-sol-xhigh", "codex", "gpt-6.1-sol", "xhigh"],
+    ]);
+    expect(profiles.every((p) => p.seededFrom === "agent-config" && p.allowCustomModel)).toBe(true);
+
+    const defaults = await getSwarmConfigs({ scope: "agent", key: "MODEL_PROFILE" });
+    expect(Object.fromEntries(defaults.map((row) => [row.scopeId, row.value]))).toEqual({
+      [a]: "claude-opus-5-5-high",
+      [b]: "claude-opus-5-5-high",
+      [c]: "codex-gpt-6.1-sol-xhigh",
+      [d]: "claude-openrouter-vendor-model-free",
+    });
+    expect(defaults.every((row) => row.exportToEnv === false)).toBe(true);
+    expect(defaults.some((row) => skipped.includes(row.scopeId ?? ""))).toBe(false);
+  });
+
+  test("an overridden agent's untiered task resolves to the same model and effort as before", async () => {
+    const id = await agentWith("m-same", "codex", "gpt-6.1-sol", "xhigh");
+    getDb().exec(agentOverrideMigrationSql());
+    const task = await getDbClient().get<{ id: string }>(
+      `INSERT INTO agent_tasks (id, agentId, task, status, source, createdAt, lastUpdatedAt)
+       VALUES ('t-same', ?, 'work', 'pending', 'mcp', '2026-01-01', '2026-01-01') RETURNING id`,
+      [id],
+    );
+    const fields = await recordClaimModelResolution(
+      { id: task?.id ?? "" },
+      { id, harnessProvider: "codex" },
+    );
+    expect(fields).toMatchObject({
+      resolvedModel: "gpt-6.1-sol",
+      modelSource: "profile:agent-default",
+      resolvedProfile: "codex-gpt-6.1-sol-xhigh",
+      effort: "xhigh",
+    });
+  });
+});