@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/src/tests/context-versioning.test.ts

@@ -10,6 +10,8 @@ import {
   initDb,
   updateAgentProfile,
 } from "../be/db";
+import type { ProfileSyncConflict } from "../types";
+import { IDENTITY_FIELD_BUDGETS } from "../utils/identity-field-budget";
 
 const TEST_DB_PATH = "./test-context-versioning.sqlite";
 
@@ -411,6 +413,111 @@ describe("Context Versioning", () => {
     });
   });
 
+  // ============================================================================
+  // Compare-and-set (expectedHashes)
+  // ============================================================================
+
+  describe("compare-and-set via expectedHashes", () => {
+    const casAgentId = "cccc0000-0000-4000-8000-000000000004";
+    const v1 = "# CLAUDE.md\n\nversion one";
+    const v2 = "# CLAUDE.md\n\nversion two — the Lead added a rule";
+    const v3 = "# CLAUDE.md\n\nversion three — edited in a session";
+
+    beforeAll(async () => {
+      await createAgent({ id: casAgentId, name: "CAS Agent", isLead: false, status: "idle" });
+      await updateAgentProfile(casAgentId, { claudeMd: v1 }, { changeSource: "self_edit" });
+      await updateAgentProfile(casAgentId, { claudeMd: v2 }, { changeSource: "self_edit" });
+    });
+
+    test("drops a copy based on a superseded version and reports the conflict", async () => {
+      // The 2026-09-11 incident: a session materialized v1, the Lead moved the
+      // DB to v2 meanwhile, and the session's end-of-run sync carried v1 back.
+      const conflicts: ProfileSyncConflict[] = [];
+      const agent = await updateAgentProfile(
+        casAgentId,
+        { claudeMd: v3 },
+        { changeSource: "session_sync" },
+        { expectedHashes: { claudeMd: sha256(v1) }, onConflict: (c) => conflicts.push(c) },
+      );
+
+      expect(agent!.claudeMd).toBe(v2);
+      expect((await getLatestContextVersion(casAgentId, "claudeMd"))!.version).toBe(2);
+      expect(conflicts).toEqual([
+        { field: "claudeMd", expectedHash: sha256(v1), currentHash: sha256(v2) },
+      ]);
+    });
+
+    test("applies a deliberate session_sync revert to an earlier version", async () => {
+      // The session was based on the current value (v2) and restored v1 on
+      // purpose. Its hash is in the history, and that must not matter.
+      const agent = await updateAgentProfile(
+        casAgentId,
+        { claudeMd: v1 },
+        { changeSource: "session_sync" },
+        { expectedHashes: { claudeMd: sha256(v2) } },
+      );
+
+      expect(agent!.claudeMd).toBe(v1);
+      const latest = await getLatestContextVersion(casAgentId, "claudeMd");
+      expect(latest!.version).toBe(3);
+      expect(latest!.content).toBe(v1);
+      expect(latest!.changeSource).toBe("session_sync");
+    });
+
+    test("the drop is per field: other fields in the same update land", async () => {
+      const soul = "s".repeat(600);
+      const agent = await updateAgentProfile(
+        casAgentId,
+        { claudeMd: v3, soulMd: soul },
+        { changeSource: "session_sync" },
+        { expectedHashes: { claudeMd: sha256(v2) } }, // stale: the DB is at v1 now
+      );
+
+      expect(agent!.claudeMd).toBe(v1);
+      expect(agent!.soulMd).toBe(soul);
+      expect((await getLatestContextVersion(casAgentId, "claudeMd"))!.version).toBe(3);
+      expect((await getLatestContextVersion(casAgentId, "soulMd"))!.version).toBe(1);
+    });
+
+    test("without expectedHashes the write stays unconditional", async () => {
+      const agent = await updateAgentProfile(
+        casAgentId,
+        { claudeMd: v2 },
+        { changeSource: "session_sync" },
+      );
+
+      expect(agent!.claudeMd).toBe(v2);
+      expect((await getLatestContextVersion(casAgentId, "claudeMd"))!.version).toBe(4);
+    });
+
+    test("a stale copy over the budget is dropped, not rejected", async () => {
+      // The profile has since been shortened under the budget. A stale copy of
+      // the old, oversized value must be dropped by the compare-and-set — not
+      // throw IdentityFieldBudgetError and roll back the other fields too.
+      const longAgentId = "cccc0000-0000-4000-8000-000000000005";
+      const oversized = "x".repeat(IDENTITY_FIELD_BUDGETS.claudeMd + 500);
+      const shortened = "# CLAUDE.md\n\nshortened below the budget";
+      await createAgent({
+        id: longAgentId,
+        name: "Long CAS Agent",
+        isLead: false,
+        status: "idle",
+      });
+      await updateAgentProfile(longAgentId, { claudeMd: shortened }, { changeSource: "self_edit" });
+
+      const soul = "t".repeat(600);
+      const agent = await updateAgentProfile(
+        longAgentId,
+        { claudeMd: oversized, soulMd: soul },
+        { changeSource: "session_sync" },
+        { expectedHashes: { claudeMd: sha256(oversized) } },
+      );
+
+      expect(agent!.claudeMd).toBe(shortened);
+      expect(agent!.soulMd).toBe(soul);
+    });
+  });
+
   // ============================================================================
   // Content hash consistency
   // ============================================================================

package/src/tests/cors-allowlist.test.ts

@@ -0,0 +1,309 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { closeDb, initDb } from "../be/db";
+import { handlePageProxy } from "../http/page-proxy";
+import { handlePages } from "../http/pages";
+import { handlePagesPublic } from "../http/pages-public";
+import {
+  isOriginAllowedForCredentials,
+  setCorsHeaders,
+  warnIfCorsAllowsAnyOrigin,
+} from "../http/utils";
+import { listenOnFreePort } from "./test-net";
+
+const ENV_KEY = "CORS_ALLOWED_ORIGINS";
+const originalEnv = process.env[ENV_KEY];
+const originalOptOut = process.env.CORS_ALLOW_ANY_ORIGIN;
+beforeEach(() => {
+  delete process.env.CORS_ALLOW_ANY_ORIGIN;
+});
+
+afterEach(() => {
+  if (originalOptOut === undefined) delete process.env.CORS_ALLOW_ANY_ORIGIN;
+  else process.env.CORS_ALLOW_ANY_ORIGIN = originalOptOut;
+  if (originalEnv === undefined) delete process.env[ENV_KEY];
+  else process.env[ENV_KEY] = originalEnv;
+});
+
+function fakeReq(origin: string | undefined): IncomingMessage {
+  return { headers: origin ? { origin } : {} } as unknown as IncomingMessage;
+}
+
+function fakeRes(): { res: ServerResponse; headers: Map<string, string> } {
+  const headers = new Map<string, string>();
+  const res = {
+    setHeader: (name: string, value: string) => {
+      headers.set(name.toLowerCase(), value);
+    },
+  } as unknown as ServerResponse;
+  return { res, headers };
+}
+
+describe("isOriginAllowedForCredentials", () => {
+  test("denies arbitrary origins when CORS_ALLOWED_ORIGINS is unset", () => {
+    delete process.env[ENV_KEY];
+    expect(isOriginAllowedForCredentials("https://evil.example")).toBe(false);
+  });
+
+  test("denies arbitrary origins when CORS_ALLOWED_ORIGINS is blank", () => {
+    process.env[ENV_KEY] = "  ";
+    expect(isOriginAllowedForCredentials("https://evil.example")).toBe(false);
+  });
+
+  test("allows only listed origins when set", () => {
+    process.env[ENV_KEY] = "https://app.example.com, https://dashboard.example.com";
+    expect(isOriginAllowedForCredentials("https://app.example.com")).toBe(true);
+    expect(isOriginAllowedForCredentials("https://dashboard.example.com")).toBe(true);
+    expect(isOriginAllowedForCredentials("https://evil.example")).toBe(false);
+  });
+
+  test.each([
+    ["matches a subdomain", "https://app.agent-swarm.dev", true],
+    ["matches multiple subdomain labels", "https://a.b.agent-swarm.dev", true],
+    ["rejects suffix confusion", "https://evil-agent-swarm.dev", false],
+    ["rejects trailing-domain attacks", "https://app.agent-swarm.dev.evil.com", false],
+    ["rejects scheme mismatch", "http://app.agent-swarm.dev", false],
+    ["compares scheme exactly", "HTTPS://app.agent-swarm.dev", false],
+    ["rejects the apex", "https://agent-swarm.dev", false],
+    ["compares host case-insensitively", "https://APP.AGENT-SWARM.DEV", true],
+    ["rejects an unlisted port", "https://app.agent-swarm.dev:8443", false],
+    ["rejects empty labels", "https://.agent-swarm.dev", false],
+    ["rejects credentials", "https://evil.com@app.agent-swarm.dev", false],
+    ["rejects paths", "https://app.agent-swarm.dev/evil", false],
+  ])("wildcard %s", (_name, origin, allowed) => {
+    process.env[ENV_KEY] = "https://*.agent-swarm.dev";
+    expect(isOriginAllowedForCredentials(origin)).toBe(allowed);
+  });
+
+  test.each([
+    "*",
+    "https://*",
+    "https://*.*.agent-swarm.dev",
+    "https://app*.agent-swarm.dev",
+  ])("ignores invalid wildcard entry %s", (entry) => {
+    process.env[ENV_KEY] = entry;
+    expect(isOriginAllowedForCredentials("https://app.agent-swarm.dev")).toBe(false);
+    expect(isOriginAllowedForCredentials(entry)).toBe(false);
+  });
+
+  test("wildcard supports uppercase suffixes and requires the configured port", () => {
+    process.env[ENV_KEY] = "https://*.AGENT-SWARM.DEV:8443";
+    expect(isOriginAllowedForCredentials("https://app.agent-swarm.dev:8443")).toBe(true);
+    expect(isOriginAllowedForCredentials("https://app.agent-swarm.dev")).toBe(false);
+    expect(isOriginAllowedForCredentials("https://app.agent-swarm.dev:443")).toBe(false);
+  });
+
+  test("mixes wildcard and exact entries including a separately listed apex", () => {
+    process.env[ENV_KEY] =
+      "https://*.agent-swarm.dev,https://agent-swarm.dev,http://localhost:5274";
+    expect(isOriginAllowedForCredentials("https://app.agent-swarm.dev")).toBe(true);
+    expect(isOriginAllowedForCredentials("https://agent-swarm.dev")).toBe(true);
+    expect(isOriginAllowedForCredentials("http://localhost:5274")).toBe(true);
+    expect(isOriginAllowedForCredentials("http://localhost:5275")).toBe(false);
+  });
+
+  test("is an exact match, not a suffix/subdomain match", () => {
+    process.env[ENV_KEY] = "https://app.example.com";
+    expect(isOriginAllowedForCredentials("https://evil.app.example.com")).toBe(false);
+    expect(isOriginAllowedForCredentials("https://app.example.com.evil.example")).toBe(false);
+  });
+});
+
+describe("setCorsHeaders", () => {
+  test("opt-out reflects arbitrary origins without granting credentials", () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    process.env.CORS_ALLOW_ANY_ORIGIN = "true";
+    process.env[ENV_KEY] = "https://trusted.example";
+    warnIfCorsAllowsAnyOrigin();
+    warnIfCorsAllowsAnyOrigin();
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]![0]).toContain("CORS_ALLOW_ANY_ORIGIN=true");
+    warn.mockRestore();
+    const { res, headers } = fakeRes();
+    setCorsHeaders(fakeReq("https://evil.example"), res);
+    expect(headers.get("access-control-allow-origin")).toBe("https://evil.example");
+    expect(headers.has("access-control-allow-credentials")).toBe(false);
+  });
+
+  test("denies a non-allowlisted origin: no Allow-Origin, no Allow-Credentials", () => {
+    process.env[ENV_KEY] = "https://app.example.com";
+    const { res, headers } = fakeRes();
+    setCorsHeaders(fakeReq("https://evil.example"), res);
+    expect(headers.has("access-control-allow-origin")).toBe(false);
+    expect(headers.has("access-control-allow-credentials")).toBe(false);
+    // Vary: Origin still set so caches don't serve a denied response to an allowed origin.
+    expect(headers.get("vary")).toBe("Origin");
+  });
+
+  test("allows a listed origin with credentials", () => {
+    process.env[ENV_KEY] = "https://app.example.com";
+    const { res, headers } = fakeRes();
+    setCorsHeaders(fakeReq("https://app.example.com"), res);
+    expect(headers.get("access-control-allow-origin")).toBe("https://app.example.com");
+    expect(headers.get("access-control-allow-credentials")).toBe("true");
+  });
+
+  test("no-Origin requests still get wildcard regardless of allowlist", () => {
+    process.env[ENV_KEY] = "https://app.example.com";
+    const { res, headers } = fakeRes();
+    setCorsHeaders(fakeReq(undefined), res);
+    expect(headers.get("access-control-allow-origin")).toBe("*");
+  });
+});
+
+describe("secure defaults and reload", () => {
+  test.each([undefined, "", "  "])("uses defaults for %j", (raw) => {
+    if (raw === undefined) delete process.env[ENV_KEY];
+    else process.env[ENV_KEY] = raw;
+    for (const origin of [
+      "https://app.agent-swarm.dev",
+      "https://a.b.agent-swarm.cloud",
+      "http://localhost:5274",
+      "http://127.0.0.1:5274",
+      "http://[::1]:5274",
+      "https://ui.swarm.localhost:1355",
+    ]) {
+      expect(isOriginAllowedForCredentials(origin)).toBe(true);
+    }
+    for (const origin of [
+      "https://evil.example",
+      "null",
+      "https://agent-swarm.dev",
+      "http://localhost:9999",
+    ]) {
+      const { res, headers } = fakeRes();
+      setCorsHeaders(fakeReq(origin), res);
+      expect(headers.has("access-control-allow-origin")).toBe(false);
+      expect(headers.has("access-control-allow-credentials")).toBe(false);
+      expect(headers.get("vary")).toBe("Origin");
+    }
+  });
+  test("custom lists replace defaults and opt-out changes are read dynamically", () => {
+    process.env[ENV_KEY] = "https://trusted.example";
+    expect(isOriginAllowedForCredentials("https://app.agent-swarm.dev")).toBe(false);
+    for (const value of ["true", "1", " TRUE "]) {
+      process.env.CORS_ALLOW_ANY_ORIGIN = value;
+      expect(isOriginAllowedForCredentials("https://evil.example")).toBe(false);
+      const { res, headers } = fakeRes();
+      setCorsHeaders(fakeReq("https://evil.example"), res);
+      expect(headers.get("access-control-allow-origin")).toBe("https://evil.example");
+      expect(headers.has("access-control-allow-credentials")).toBe(false);
+    }
+    for (const value of ["false", "0", "", "typo"]) {
+      process.env.CORS_ALLOW_ANY_ORIGIN = value;
+      expect(isOriginAllowedForCredentials("https://evil.example")).toBe(false);
+    }
+    process.env[ENV_KEY] = "https://evil.example";
+    expect(isOriginAllowedForCredentials("https://evil.example")).toBe(true);
+  });
+});
+
+describe("page-session CORS over HTTP", () => {
+  const originalPort = process.env.PORT;
+  const dir = mkdtempSync(join(tmpdir(), "cors-pages-"));
+  const server = createServer(async (req, res) => {
+    setCorsHeaders(req, res);
+    const url = new URL(req.url!, "http://localhost");
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204).end();
+      return;
+    }
+    if (await handlePageProxy(req, res)) return;
+    if (
+      await handlePages(
+        req,
+        res,
+        segments,
+        url.searchParams,
+        "38d36438-58a0-45b5-8602-a5d52b07c2f1",
+      )
+    )
+      return;
+    if (await handlePagesPublic(req, res, segments, url.searchParams)) return;
+    res.writeHead(404).end();
+  });
+  let base: string;
+  let pageId: string;
+  beforeAll(async () => {
+    initDb(join(dir, "test.sqlite"));
+    const port = await listenOnFreePort(server);
+    process.env.PORT = String(port);
+    base = `http://localhost:${port}`;
+    const response = await fetch(`${base}/api/pages`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        slug: "cors-session",
+        title: "CORS",
+        contentType: "text/html",
+        authMode: "authed",
+        body: "<h1>Private</h1>",
+      }),
+    });
+    expect(response.status).toBe(201);
+    pageId = ((await response.json()) as { id: string }).id;
+  });
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    if (originalPort === undefined) delete process.env.PORT;
+    else process.env.PORT = originalPort;
+    rmSync(dir, { recursive: true, force: true });
+  });
+  test.each([
+    undefined,
+    "",
+    "  ",
+    "bypass",
+  ])("launch preflight, session cookie and page JSON use defaults for %j", async (raw) => {
+    const bypass = raw === "bypass";
+    if (bypass) process.env.CORS_ALLOW_ANY_ORIGIN = "true";
+    if (raw === undefined || bypass) delete process.env[ENV_KEY];
+    else process.env[ENV_KEY] = raw;
+    for (const origin of ["https://app.agent-swarm.dev", "https://evil.example"]) {
+      const allowed = origin.includes("agent-swarm.dev");
+      for (const method of ["OPTIONS", "POST"]) {
+        const response = await fetch(`${base}/api/pages/${pageId}/launch`, {
+          method,
+          headers: { Origin: origin },
+        });
+        expect(response.status).toBe(204);
+        expect(response.headers.get("access-control-allow-origin")).toBe(
+          allowed || bypass ? origin : null,
+        );
+        expect(response.headers.get("access-control-allow-credentials")).toBe(
+          allowed ? "true" : null,
+        );
+        if (method === "POST") {
+          const cookie = response.headers.get("set-cookie")!.split(";")[0]!;
+          for (const path of [`/p/${pageId}.json`, `/@swarm/api/pages/${pageId}`]) {
+            const page = await fetch(`${base}${path}`, {
+              headers: { Origin: origin, Cookie: cookie },
+            });
+            expect(page.status).toBe(200);
+            expect(page.headers.get("access-control-allow-origin")).toBe(
+              allowed || bypass ? origin : null,
+            );
+            expect(page.headers.get("access-control-allow-credentials")).toBe(
+              allowed ? "true" : null,
+            );
+            await page.text();
+          }
+        }
+      }
+    }
+  });
+});

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

@@ -2,8 +2,11 @@ import { describe, expect, mock, test } from "bun:test";
 import {
   buildCredStatusReport,
   checkProviderCredentials,
+  isBedrockMode,
   isCredCheckDisabled,
   REQUIRED_CRED_VARS_BY_PROVIDER,
+  shouldRefreshBedrockStatus,
+  validateProviderCredentials,
 } from "../commands/provider-credentials";
 import { checkClaudeCredentials } from "../providers/claude-adapter";
 import { checkClaudeManagedCredentials } from "../providers/claude-managed-adapter";
@@ -410,21 +413,69 @@ describe("checkPiMonoCredentials", () => {
     expect(status.ready).toBe(false);
   });
 
-  test("BEDROCK_AUTH_MODE=bearer: does NOT trigger the sdk probe (falls through)", async () => {
-    // The bearer path is declared/validated but the full implementation is
-    // not implemented yet. With no other credentials set it should be not-ready
-    // via the standard permissive check, not via the sdk probe.
-    const env = { BEDROCK_AUTH_MODE: "bearer" };
-    // No other keys set, no auth.json → not-ready from the permissive path.
-    const status = await checkPiMonoCredentials(env, { homeDir: HOME, fs: noFiles });
+  // ─── BEDROCK_AUTH_MODE=bearer: explicit Bedrock API key ─────────────────────
+
+  test("BEDROCK_AUTH_MODE=bearer: missing AWS_BEARER_TOKEN_BEDROCK → not ready, no probe, no fall-through", async () => {
+    let probed = false;
+    // A standard key must not satisfy the bearer mode: it does not apply to Bedrock.
+    const env = { BEDROCK_AUTH_MODE: "bearer", AWS_REGION: "us-east-1", ANTHROPIC_API_KEY: "x" };
+    const status = await checkPiMonoCredentials(env, {
+      homeDir: HOME,
+      fs: noFiles,
+      bedrockProbe: async () => {
+        probed = true;
+      },
+    });
     expect(status.ready).toBe(false);
-    // Satisfying via any standard key still works for the bearer mode today.
-    const withKey = await checkPiMonoCredentials(
-      { BEDROCK_AUTH_MODE: "bearer", ANTHROPIC_API_KEY: "x" },
-      { homeDir: HOME, fs: noFiles },
-    );
-    expect(withKey.ready).toBe(true);
-    expect(withKey.satisfiedBy).toBe("env");
+    expect(status.missing).toEqual(["AWS_BEARER_TOKEN_BEDROCK"]);
+    expect(status.hint).toContain("AWS_BEARER_TOKEN_BEDROCK");
+    expect(probed).toBe(false);
+  });
+
+  test("BEDROCK_AUTH_MODE=bearer: token without AWS_REGION → not ready with the region hint", async () => {
+    const env = { BEDROCK_AUTH_MODE: "bearer", AWS_BEARER_TOKEN_BEDROCK: "bedrock-api-key" };
+    const status = await checkPiMonoCredentials(env, {
+      homeDir: HOME,
+      fs: noFiles,
+      bedrockProbe: bedrockProbeSuccess,
+    });
+    expect(status.ready).toBe(false);
+    expect(status.hint).toContain("AWS_REGION");
+    expect(status.bedrockRegion).toBe("");
+  });
+
+  test("BEDROCK_AUTH_MODE=bearer: token + region → probe runs, ready via env", async () => {
+    const env = {
+      BEDROCK_AUTH_MODE: "bearer",
+      AWS_BEARER_TOKEN_BEDROCK: "bedrock-api-key",
+      AWS_REGION: "eu-central-1",
+    };
+    const status = await checkPiMonoCredentials(env, {
+      homeDir: HOME,
+      fs: noFiles,
+      bedrockProbe: async () => [{ id: "anthropic.claude-sonnet", name: "Claude Sonnet" }],
+    });
+    expect(status.ready).toBe(true);
+    expect(status.satisfiedBy).toBe("env");
+    expect(status.bedrockRegion).toBe("eu-central-1");
+    expect(status.bedrockModels).toEqual([
+      { id: "anthropic.claude-sonnet", name: "Claude Sonnet" },
+    ]);
+  });
+
+  test("BEDROCK_AUTH_MODE=bearer: probe failure → ready:false with the classified hint", async () => {
+    const env = {
+      BEDROCK_AUTH_MODE: "bearer",
+      AWS_BEARER_TOKEN_BEDROCK: "bedrock-api-key",
+      AWS_REGION: "us-east-1",
+    };
+    const status = await checkPiMonoCredentials(env, {
+      homeDir: HOME,
+      fs: noFiles,
+      bedrockProbe: bedrockProbeAuthFail,
+    });
+    expect(status.ready).toBe(false);
+    expect(status.bedrockRegion).toBe("us-east-1");
   });
 
   test("BEDROCK_AUTH_MODE absent + no MODEL_OVERRIDE=amazon-bedrock: no probe", async () => {
@@ -689,6 +740,98 @@ describe("snapshot: every provider", () => {
 
 // ─── REQUIRED_CRED_VARS_BY_PROVIDER documentation map ────────────────────────
 
+describe("isBedrockMode (shared gate for the live test and the refresh loop)", () => {
+  test("recognizes both explicit modes and the MODEL_OVERRIDE prefix inference", () => {
+    expect(isBedrockMode({ BEDROCK_AUTH_MODE: "sdk" })).toBe(true);
+    expect(isBedrockMode({ BEDROCK_AUTH_MODE: "bearer" })).toBe(true);
+    expect(isBedrockMode({ BEDROCK_AUTH_MODE: "Bearer", MODEL_OVERRIDE: "some-model" })).toBe(true);
+    expect(isBedrockMode({ MODEL_OVERRIDE: "amazon-bedrock/anthropic.claude" })).toBe(true);
+    expect(isBedrockMode({ MODEL_OVERRIDE: "anthropic/claude" })).toBe(false);
+    expect(isBedrockMode({})).toBe(false);
+  });
+});
+
+describe("shouldRefreshBedrockStatus (runner post-task refresh gate)", () => {
+  const INTERVAL = 5 * 60 * 1000;
+  const base = { harnessProvider: "pi", lastRefreshAt: 1_000, intervalMs: INTERVAL };
+
+  test("bearer-only pi configuration is refreshed once the interval has elapsed", () => {
+    const env = {
+      BEDROCK_AUTH_MODE: "bearer",
+      AWS_BEARER_TOKEN_BEDROCK: "tok",
+      AWS_REGION: "us-east-1",
+    };
+    expect(shouldRefreshBedrockStatus({ ...base, env, now: 1_000 + INTERVAL + 1 })).toBe(true);
+  });
+
+  test("bearer mode stays throttled inside the interval", () => {
+    const env = {
+      BEDROCK_AUTH_MODE: "bearer",
+      AWS_BEARER_TOKEN_BEDROCK: "tok",
+      AWS_REGION: "us-east-1",
+    };
+    expect(shouldRefreshBedrockStatus({ ...base, env, now: 1_000 + INTERVAL })).toBe(false);
+    expect(shouldRefreshBedrockStatus({ ...base, env, now: 1_000 + 1 })).toBe(false);
+  });
+
+  test("sdk mode and the amazon-bedrock/ prefix inference refresh the same way", () => {
+    const now = 1_000 + INTERVAL + 1;
+    expect(shouldRefreshBedrockStatus({ ...base, env: { BEDROCK_AUTH_MODE: "sdk" }, now })).toBe(
+      true,
+    );
+    expect(
+      shouldRefreshBedrockStatus({
+        ...base,
+        env: { MODEL_OVERRIDE: "amazon-bedrock/anthropic.claude" },
+        now,
+      }),
+    ).toBe(true);
+  });
+
+  test("never fires outside Bedrock mode or for a non-pi harness", () => {
+    const now = 1_000 + INTERVAL + 1;
+    expect(shouldRefreshBedrockStatus({ ...base, env: { ANTHROPIC_API_KEY: "sk" }, now })).toBe(
+      false,
+    );
+    expect(
+      shouldRefreshBedrockStatus({ ...base, env: { MODEL_OVERRIDE: "anthropic/claude" }, now }),
+    ).toBe(false);
+    expect(
+      shouldRefreshBedrockStatus({
+        ...base,
+        harnessProvider: "claude",
+        env: { BEDROCK_AUTH_MODE: "bearer" },
+        now,
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("validateProviderCredentials: pi Bedrock pass-through", () => {
+  const saved = { ...process.env };
+  const restore = () => {
+    for (const key of Object.keys(process.env)) if (!(key in saved)) delete process.env[key];
+    Object.assign(process.env, saved);
+  };
+
+  test("bearer mode is a pass-through like sdk mode: no provider-key live test is issued", async () => {
+    const realFetch = globalThis.fetch;
+    // A stray provider key must not be live-tested: the Bedrock enumeration already ran.
+    process.env.BEDROCK_AUTH_MODE = "bearer";
+    process.env.AWS_BEARER_TOKEN_BEDROCK = "bedrock-api-key";
+    process.env.ANTHROPIC_API_KEY = "x";
+    globalThis.fetch = (async () => {
+      throw new Error("live test must not reach the network in Bedrock mode");
+    }) as typeof fetch;
+    try {
+      expect(await validateProviderCredentials("pi")).toEqual({ ok: true, latency_ms: 0 });
+    } finally {
+      globalThis.fetch = realFetch;
+      restore();
+    }
+  });
+});
+
 describe("REQUIRED_CRED_VARS_BY_PROVIDER", () => {
   test("covers every supported provider", () => {
     const providers = ["claude", "claude-managed", "codex", "devin", "opencode", "pi"] as const;