@desplega.ai/agent-swarm 1.75.0 → 1.76.0

package/src/tests/agents-harness-provider.test.ts

@@ -0,0 +1,333 @@
+/**
+ * Phase 1.5 (cloud-personalization): per-agent harness_provider column +
+ * worker registration push + PATCH /api/agents/:id/harness-provider.
+ *
+ * Coverage:
+ *   - Migration applies cleanly (the test bootstrap runs `initDb` which
+ *     applies all migrations forward-only; existence of the column is
+ *     verified via PRAGMA below).
+ *   - Worker registration with `harness_provider` writes the column.
+ *   - Re-registration updates the column when the value changes.
+ *   - `PATCH /api/agents/:id/harness-provider` updates the column.
+ *   - Invalid provider names rejected with 400.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+import {
+  closeDb,
+  createAgent,
+  getAgentById,
+  getAgentHarnessProviders,
+  getDb,
+  getSwarmConfigs,
+  initDb,
+  setAgentHarnessProvider,
+} from "../be/db";
+import { handleAgentRegister, handleAgentsRest } from "../http/agents";
+
+const TEST_DB_PATH = "./test-agents-harness-provider.sqlite";
+const TEST_PORT = 13059;
+
+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;
+    }
+  }
+}
+
+function makeTestServer(): Server {
+  return createHttpServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${TEST_PORT}`);
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    const queryParams = url.searchParams;
+    const myAgentId = (req.headers["x-agent-id"] as string | undefined) ?? undefined;
+
+    try {
+      if (await handleAgentRegister(req, res, pathSegments, myAgentId)) return;
+      if (await handleAgentsRest(req, res, pathSegments, queryParams, myAgentId)) return;
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: (err as Error).message }));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+}
+
+let server: Server;
+const baseUrl = `http://localhost:${TEST_PORT}`;
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  server = makeTestServer();
+  await new Promise<void>((resolve) => {
+    server.listen(TEST_PORT, () => resolve());
+  });
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => {
+    server.close(() => resolve());
+  });
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(() => {
+  // Each test starts on an empty agents table.
+  getDb().prepare("DELETE FROM agents").run();
+  getDb().prepare("DELETE FROM swarm_config").run();
+});
+
+// ─── Migration: column exists ────────────────────────────────────────────────
+
+describe("migration 054_agent_harness_provider", () => {
+  test("`harness_provider` column exists on the `agents` table", () => {
+    const cols = getDb()
+      .prepare<{ name: string }, []>(`PRAGMA table_info(agents)`)
+      .all()
+      .map((r) => r.name);
+    expect(cols).toContain("harness_provider");
+  });
+
+  test("existing agent rows default to NULL `harness_provider`", () => {
+    const a = createAgent({
+      name: "legacy-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    expect(a.harnessProvider).toBeNull();
+  });
+});
+
+// ─── DB helpers ──────────────────────────────────────────────────────────────
+
+describe("DB helpers", () => {
+  test("setAgentHarnessProvider writes and returns the updated row", () => {
+    const a = createAgent({ name: "a1", isLead: false, status: "idle", capabilities: [] });
+    expect(a.harnessProvider).toBeNull();
+
+    const updated = setAgentHarnessProvider(a.id, "codex");
+    expect(updated?.harnessProvider).toBe("codex");
+
+    const fetched = getAgentById(a.id);
+    expect(fetched?.harnessProvider).toBe("codex");
+  });
+
+  test("setAgentHarnessProvider can clear the column with null", () => {
+    const a = createAgent({
+      name: "a-clear",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      harnessProvider: "claude",
+    });
+    expect(a.harnessProvider).toBe("claude");
+
+    const updated = setAgentHarnessProvider(a.id, null);
+    expect(updated?.harnessProvider).toBeNull();
+  });
+
+  test("setAgentHarnessProvider returns null when agent not found", () => {
+    const result = setAgentHarnessProvider("nonexistent-id", "claude");
+    expect(result).toBeNull();
+  });
+
+  test("getAgentHarnessProviders aggregates by provider, excluding NULL", () => {
+    createAgent({
+      name: "x1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      harnessProvider: "claude",
+    });
+    createAgent({
+      name: "x2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      harnessProvider: "claude",
+    });
+    createAgent({
+      name: "x3",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      harnessProvider: "codex",
+    });
+    createAgent({ name: "x4", isLead: false, status: "idle", capabilities: [] }); // NULL — excluded
+
+    const counts = getAgentHarnessProviders();
+    expect(counts).toEqual([
+      { provider: "claude", count: 2 },
+      { provider: "codex", count: 1 },
+    ]);
+  });
+});
+
+// ─── Worker registration: HTTP path ──────────────────────────────────────────
+
+describe("POST /api/agents — worker registration pushes harness_provider", () => {
+  test("first-time register persists harness_provider", async () => {
+    const agentId = "agent-register-1";
+    const res = await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({
+        name: "worker-fresh",
+        isLead: false,
+        harness_provider: "claude",
+      }),
+    });
+    expect(res.status).toBe(201);
+
+    const row = getAgentById(agentId);
+    expect(row?.harnessProvider).toBe("claude");
+  });
+
+  test("re-register with a different harness_provider updates the column", async () => {
+    const agentId = "agent-register-2";
+    // First register with claude.
+    await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ name: "worker-rotating", isLead: false, harness_provider: "claude" }),
+    });
+
+    // Re-register with codex.
+    const res = await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ name: "worker-rotating", isLead: false, harness_provider: "codex" }),
+    });
+    expect(res.status).toBe(200);
+
+    const row = getAgentById(agentId);
+    expect(row?.harnessProvider).toBe("codex");
+  });
+
+  test("registration WITHOUT harness_provider leaves an existing column value untouched", async () => {
+    const agentId = "agent-register-3";
+    // First register with claude.
+    await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ name: "worker-quiet", isLead: false, harness_provider: "claude" }),
+    });
+
+    // Re-register without harness_provider (older worker).
+    const res = await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": agentId },
+      body: JSON.stringify({ name: "worker-quiet", isLead: false }),
+    });
+    expect(res.status).toBe(200);
+
+    // Existing value preserved (so PATCH overrides aren't clobbered by
+    // older workers re-registering without the field).
+    const row = getAgentById(agentId);
+    expect(row?.harnessProvider).toBe("claude");
+  });
+
+  test("rejects an unknown provider name with 400", async () => {
+    const res = await fetch(`${baseUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": "agent-bad" },
+      body: JSON.stringify({
+        name: "worker-bad-provider",
+        isLead: false,
+        harness_provider: "rogue-llm",
+      }),
+    });
+    expect(res.status).toBe(400);
+  });
+});
+
+// ─── PATCH /api/agents/:id/harness-provider ─────────────────────────────────
+
+describe("PATCH /api/agents/:id/harness-provider", () => {
+  test("updates the column on a known agent", async () => {
+    const a = createAgent({
+      name: "patch-target-1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const res = await fetch(`${baseUrl}/api/agents/${a.id}/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "codex" }),
+    });
+    expect(res.status).toBe(200);
+
+    const row = getAgentById(a.id);
+    expect(row?.harnessProvider).toBe("codex");
+  });
+
+  test("rejects unknown provider names with 400", async () => {
+    const a = createAgent({
+      name: "patch-target-2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const res = await fetch(`${baseUrl}/api/agents/${a.id}/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "rogue" }),
+    });
+    expect(res.status).toBe(400);
+  });
+
+  test("returns 404 when agent does not exist", async () => {
+    const res = await fetch(`${baseUrl}/api/agents/nonexistent-agent-id/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "claude" }),
+    });
+    expect(res.status).toBe(404);
+  });
+
+  test("PATCH also upserts swarm_config (scope=agent) so the worker reconciles", async () => {
+    const a = createAgent({
+      name: "patch-target-3",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const res = await fetch(`${baseUrl}/api/agents/${a.id}/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "codex" }),
+    });
+    expect(res.status).toBe(200);
+
+    const rows = getSwarmConfigs({ scope: "agent", scopeId: a.id });
+    const harnessRow = rows.find((r) => r.key === "HARNESS_PROVIDER");
+    expect(harnessRow?.value).toBe("codex");
+
+    // Subsequent PATCH (different value) updates the row in place.
+    const res2 = await fetch(`${baseUrl}/api/agents/${a.id}/harness-provider`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "claude" }),
+    });
+    expect(res2.status).toBe(200);
+
+    const rows2 = getSwarmConfigs({ scope: "agent", scopeId: a.id });
+    const harnessRow2 = rows2.find((r) => r.key === "HARNESS_PROVIDER");
+    expect(harnessRow2?.value).toBe("claude");
+    expect(rows2.filter((r) => r.key === "HARNESS_PROVIDER")).toHaveLength(1);
+  });
+});

package/src/tests/credential-check.test.ts

@@ -1,8 +1,13 @@
 import { describe, expect, test } from "bun:test";
+import {
+  buildCredStatusReport,
+  checkProviderCredentials,
+  isCredCheckDisabled,
+  REQUIRED_CRED_VARS_BY_PROVIDER,
+} from "../commands/provider-credentials";
 import { checkClaudeCredentials } from "../providers/claude-adapter";
 import { checkClaudeManagedCredentials } from "../providers/claude-managed-adapter";
 import { checkCodexCredentials } from "../providers/codex-adapter";
-import { checkProviderCredentials, REQUIRED_CRED_VARS_BY_PROVIDER } from "../providers/credentials";
 import { checkDevinCredentials } from "../providers/devin-adapter";
 import { checkOpencodeCredentials } from "../providers/opencode-adapter";
 import { checkPiMonoCredentials } from "../providers/pi-mono-adapter";
@@ -334,3 +339,29 @@ describe("REQUIRED_CRED_VARS_BY_PROVIDER", () => {
     }
   });
 });
+
+// ─── Migration 055: report composition + opt-out ────────────────────────────
+
+describe("isCredCheckDisabled", () => {
+  test("true only when CRED_CHECK_DISABLE === '1'", () => {
+    expect(isCredCheckDisabled({})).toBe(false);
+    expect(isCredCheckDisabled({ CRED_CHECK_DISABLE: "0" })).toBe(false);
+    expect(isCredCheckDisabled({ CRED_CHECK_DISABLE: "true" })).toBe(false);
+    expect(isCredCheckDisabled({ CRED_CHECK_DISABLE: "1" })).toBe(true);
+  });
+});
+
+describe("buildCredStatusReport", () => {
+  test("not ready → no live test, snapshot mirrors presence check", async () => {
+    const snap = await buildCredStatusReport("claude", {}, {}, "boot");
+    expect(snap.ready).toBe(false);
+    expect(snap.liveTest).toBeNull();
+    expect(snap.reportKind).toBe("boot");
+    expect(snap.missing.length).toBeGreaterThan(0);
+  });
+
+  test("post_task kind is preserved on the snapshot", async () => {
+    const snap = await buildCredStatusReport("claude", {}, {}, "post_task");
+    expect(snap.reportKind).toBe("post_task");
+  });
+});

package/src/tests/credential-status-api.test.ts

@@ -178,4 +178,46 @@ describe("Phase 4 — credential-status HTTP endpoints", () => {
     });
     expect(resp.status).toBe(404);
   });
+
+  // Migration 055 — round-trip the new `cred_status` field.
+  test("PUT /credential-status round-trips a cred_status snapshot", async () => {
+    const snapshot = {
+      ready: true,
+      missing: [],
+      satisfiedBy: "env" as const,
+      hint: null,
+      liveTest: { ok: true, error: null, latency_ms: 91, testedAt: Date.now() },
+      reportedAt: Date.now(),
+      reportKind: "boot" as const,
+    };
+    const put = await fetch(`${baseUrl}/api/agents/${readyAgentId}/credential-status`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ready: true, missing: [], cred_status: snapshot }),
+    });
+    expect(put.status).toBe(200);
+
+    const get = await fetch(`${baseUrl}/api/agents/${readyAgentId}/credential-status`);
+    const body = (await get.json()) as {
+      credStatus: typeof snapshot | null;
+    };
+    expect(body.credStatus).toMatchObject({
+      ready: true,
+      satisfiedBy: "env",
+      reportKind: "boot",
+      liveTest: { ok: true, latency_ms: 91 },
+    });
+  });
+
+  test("PUT rejects a malformed cred_status payload (Zod validation)", async () => {
+    const resp = await fetch(`${baseUrl}/api/agents/${readyAgentId}/credential-status`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ready: true,
+        cred_status: { ready: "not-a-boolean", reportedAt: Date.now() }, // bad shape
+      }),
+    });
+    expect(resp.status).toBe(400);
+  });
 });

package/src/tests/harness-provider-resolution.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Coverage for the swarm_config-overrides-HARNESS_PROVIDER work:
+ *
+ *   - `resolveHarnessProvider` precedence (resolvedEnv > fallbackEnv > "claude")
+ *     and invalid-value fallback.
+ *   - `validateConfigValue` rejects unknown providers (used by HTTP +
+ *     MCP write paths).
+ *   - `getResolvedConfig` honours scope precedence (repo > agent > global)
+ *     for HARNESS_PROVIDER, mirroring how MODEL_OVERRIDE already works.
+ *   - End-to-end through `PUT /api/config`: a typo'd HARNESS_PROVIDER is
+ *     rejected with 400 instead of being silently stored.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+import {
+  closeDb,
+  createAgent,
+  getDb,
+  getResolvedConfig,
+  initDb,
+  upsertSwarmConfig,
+} from "../be/db";
+import { validateConfigValue } from "../be/swarm-config-guard";
+import { handleConfig } from "../http/config";
+import { resolveHarnessProvider } from "../utils/harness-provider";
+
+const TEST_DB_PATH = "./test-harness-provider-resolution.sqlite";
+const TEST_PORT = 13061;
+
+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;
+    }
+  }
+}
+
+function makeTestServer(): Server {
+  return createHttpServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${TEST_PORT}`);
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    const queryParams = url.searchParams;
+    try {
+      if (await handleConfig(req, res, pathSegments, queryParams)) return;
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: (err as Error).message }));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+}
+
+let server: Server;
+const baseUrl = `http://localhost:${TEST_PORT}`;
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  server = makeTestServer();
+  await new Promise<void>((resolve) => {
+    server.listen(TEST_PORT, () => resolve());
+  });
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => {
+    server.close(() => resolve());
+  });
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(() => {
+  getDb().prepare("DELETE FROM swarm_config").run();
+  getDb().prepare("DELETE FROM agents").run();
+});
+
+// ─── resolveHarnessProvider ──────────────────────────────────────────────────
+
+describe("resolveHarnessProvider", () => {
+  test("returns 'claude' when neither env has HARNESS_PROVIDER", () => {
+    expect(resolveHarnessProvider({}, {})).toBe("claude");
+  });
+
+  test("returns the value from resolvedEnv (swarm_config overlay) when present", () => {
+    expect(
+      resolveHarnessProvider({ HARNESS_PROVIDER: "codex" }, { HARNESS_PROVIDER: "claude" }),
+    ).toBe("codex");
+  });
+
+  test("falls back to fallbackEnv when resolvedEnv lacks the key", () => {
+    expect(resolveHarnessProvider({}, { HARNESS_PROVIDER: "pi" })).toBe("pi");
+  });
+
+  test("ignores empty string in resolvedEnv and falls back", () => {
+    expect(resolveHarnessProvider({ HARNESS_PROVIDER: "  " }, { HARNESS_PROVIDER: "codex" })).toBe(
+      "codex",
+    );
+  });
+
+  test("invalid value falls back to 'claude' (does not throw)", () => {
+    expect(resolveHarnessProvider({ HARNESS_PROVIDER: "not-a-provider" }, {})).toBe("claude");
+  });
+
+  test("trims whitespace before validating", () => {
+    expect(resolveHarnessProvider({ HARNESS_PROVIDER: "  codex  " }, {})).toBe("codex");
+  });
+});
+
+// ─── validateConfigValue ─────────────────────────────────────────────────────
+
+describe("validateConfigValue", () => {
+  test("returns null for keys without a validator", () => {
+    expect(validateConfigValue("FOO_BAR", "anything")).toBeNull();
+    expect(validateConfigValue("MODEL_OVERRIDE", "sonnet")).toBeNull();
+  });
+
+  test("accepts a valid HARNESS_PROVIDER", () => {
+    expect(validateConfigValue("HARNESS_PROVIDER", "codex")).toBeNull();
+    expect(validateConfigValue("harness_provider", "claude")).toBeNull(); // case-insensitive
+  });
+
+  test("rejects an unknown HARNESS_PROVIDER with a helpful error", () => {
+    const err = validateConfigValue("HARNESS_PROVIDER", "claude-cod");
+    expect(err).not.toBeNull();
+    expect(err).toMatch(/HARNESS_PROVIDER/);
+    expect(err).toMatch(/claude/);
+    expect(err).toMatch(/codex/);
+  });
+
+  test("rejects non-string values for HARNESS_PROVIDER", () => {
+    expect(validateConfigValue("HARNESS_PROVIDER", 42)).not.toBeNull();
+    expect(validateConfigValue("HARNESS_PROVIDER", null)).not.toBeNull();
+  });
+});
+
+// ─── getResolvedConfig — scope precedence for HARNESS_PROVIDER ───────────────
+
+describe("getResolvedConfig precedence for HARNESS_PROVIDER", () => {
+  test("agent scope wins over global scope", () => {
+    const a = createAgent({
+      name: "scope-test-1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    upsertSwarmConfig({ scope: "global", key: "HARNESS_PROVIDER", value: "claude" });
+    upsertSwarmConfig({
+      scope: "agent",
+      scopeId: a.id,
+      key: "HARNESS_PROVIDER",
+      value: "codex",
+    });
+
+    const resolved = getResolvedConfig(a.id);
+    const harness = resolved.find((c) => c.key === "HARNESS_PROVIDER");
+    expect(harness?.value).toBe("codex");
+  });
+
+  test("global scope applies when no agent-scoped row exists", () => {
+    const a = createAgent({
+      name: "scope-test-2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    upsertSwarmConfig({ scope: "global", key: "HARNESS_PROVIDER", value: "pi" });
+
+    const resolved = getResolvedConfig(a.id);
+    const harness = resolved.find((c) => c.key === "HARNESS_PROVIDER");
+    expect(harness?.value).toBe("pi");
+  });
+
+  test("nothing resolved when no rows exist (env fallback handled by runner)", () => {
+    const resolved = getResolvedConfig("agent-nonexistent");
+    expect(resolved.find((c) => c.key === "HARNESS_PROVIDER")).toBeUndefined();
+  });
+});
+
+// ─── PUT /api/config — guard rejects invalid HARNESS_PROVIDER ────────────────
+
+describe("PUT /api/config rejects invalid HARNESS_PROVIDER", () => {
+  test("400 when value is not in ProviderNameSchema", async () => {
+    const res = await fetch(`${baseUrl}/api/config`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        scope: "global",
+        key: "HARNESS_PROVIDER",
+        value: "not-a-real-provider",
+      }),
+    });
+    expect(res.status).toBe(400);
+    const body = (await res.json()) as { error: string };
+    expect(body.error).toMatch(/HARNESS_PROVIDER/);
+  });
+
+  test("200 for a valid value, persists row", async () => {
+    const res = await fetch(`${baseUrl}/api/config`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        scope: "global",
+        key: "HARNESS_PROVIDER",
+        value: "codex",
+      }),
+    });
+    expect(res.status).toBe(200);
+
+    const rows = getResolvedConfig();
+    const harness = rows.find((c) => c.key === "HARNESS_PROVIDER");
+    expect(harness?.value).toBe("codex");
+  });
+
+  test("400 still rejects via PUT when scope=agent", async () => {
+    const a = createAgent({
+      name: "scope-test-3",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const res = await fetch(`${baseUrl}/api/config`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        scope: "agent",
+        scopeId: a.id,
+        key: "HARNESS_PROVIDER",
+        value: "claude-codex",
+      }),
+    });
+    expect(res.status).toBe(400);
+  });
+});

package/src/tests/jira-sync.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, completeTask, createAgent, getDb, getTaskById, initDb } from "../be/db";
 import { upsertOAuthApp } from "../be/db-queries/oauth";