@desplega.ai/agent-swarm 2.7.4 → 2.7.5

package/src/tests/codex-oauth-refresh-egress.test.ts

@@ -0,0 +1,194 @@
+/**
+ * A pool refresh or persist failure must never print a token. The OpenAI
+ * token endpoint and the config store may echo the request body in an error
+ * response; that text reaches console logs, the thrown error and, through
+ * `buildPoolRevalidationFailureReason`, the task's failure reason.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { resetFetchForTesting, setFetchForTesting } from "../providers/codex-oauth/flow.js";
+import { persistCodexOAuth, storeCodexOAuth } from "../providers/codex-oauth/storage.js";
+import { loadChatgptSubscriptionCredential } from "../providers/codex-oauth/subscription.js";
+import type { CodexOAuthCredentials } from "../providers/codex-oauth/types.js";
+import { isCodexAuthFailureReason } from "../utils/codex-auth-failure";
+
+const API_URL = "http://localhost:3013";
+const OLD_REFRESH = "rt_synthetic_pool_refresh_0123456789abcdef";
+const NEW_ACCESS = "at_synthetic_rotated_access_0123456789abcdef";
+const NEW_REFRESH = "rt_synthetic_rotated_refresh_0123456789abcdef";
+const SECRETS = [OLD_REFRESH, NEW_ACCESS, NEW_REFRESH];
+const CONFIG = { apiUrl: API_URL, apiKey: "test-key", codexSlot: 0, model: "openai-codex/gpt-5.5" };
+
+const originalFetch = globalThis.fetch;
+let logged: string[] = [];
+const spies: Array<{ mockRestore: () => void }> = [];
+
+/** A transport error whose message echoes the request carrying the tokens. */
+function rejectedPersist(): never {
+  throw new TypeError(
+    `fetch failed: socket closed while sending {"value":"{\\"access\\":\\"${NEW_ACCESS}\\",\\"refresh\\":\\"${NEW_REFRESH}\\"}"} (${encodeURIComponent(NEW_REFRESH)})`,
+  );
+}
+
+/** Config store holding one expired slot; `putResponse` answers the persist. */
+function installConfigStore(putResponse: () => Response): void {
+  const creds: CodexOAuthCredentials = {
+    access: "at_expired",
+    refresh: OLD_REFRESH,
+    expires: Date.now() - 1000,
+    accountId: "acct-egress",
+  };
+  globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+    const href = url.toString();
+    const method = (init?.method ?? "GET").toUpperCase();
+    if (href.includes("/api/oauth/refresh-locks/")) {
+      return Response.json(method === "POST" ? { owner: "owner-1" } : { released: true });
+    }
+    if (method === "GET" && href.includes("/api/config/resolved")) {
+      return Response.json({ configs: [{ key: "codex_oauth_0", value: JSON.stringify(creds) }] });
+    }
+    if (method === "PUT" && href.includes("/api/config")) return putResponse();
+    if (method === "DELETE" && href.includes("/api/config")) return Response.json({});
+    throw new Error(`Unexpected fetch: ${method} ${href}`);
+  }) as typeof fetch;
+}
+
+async function failureOf(promise: Promise<unknown>): Promise<string> {
+  try {
+    await promise;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+  throw new Error("expected a rejection");
+}
+
+function expectNoSecret(text: string): void {
+  for (const secret of SECRETS) {
+    expect(text).not.toContain(secret);
+    expect(text).not.toContain(encodeURIComponent(secret));
+  }
+}
+
+beforeEach(() => {
+  logged = [];
+  for (const method of ["log", "error", "warn"] as const) {
+    spies.push(
+      spyOn(console, method).mockImplementation((...args: unknown[]) => {
+        logged.push(args.map((a) => (typeof a === "string" ? a : Bun.inspect(a))).join(" "));
+      }),
+    );
+  }
+});
+
+afterEach(() => {
+  for (const spy of spies.splice(0)) spy.mockRestore();
+  globalThis.fetch = originalFetch;
+  resetFetchForTesting();
+});
+
+describe("pool refresh failure egress", () => {
+  test("a 401 echoing the submitted refresh token is redacted and still counts", async () => {
+    installConfigStore(() => Response.json({}));
+    setFetchForTesting((async (_url: string | URL | Request, init?: RequestInit) => {
+      const form = String(init?.body ?? "");
+      return new Response(
+        JSON.stringify({ error: "invalid_grant", echo: OLD_REFRESH, request: form }),
+        { status: 401 },
+      );
+    }) as typeof fetch);
+
+    const reason = await failureOf(loadChatgptSubscriptionCredential(CONFIG));
+
+    expect(reason).toContain("refresh rejected (401");
+    expect(reason).toContain("invalid_grant");
+    expect(isCodexAuthFailureReason(reason)).toBe(true);
+    expectNoSecret(reason);
+    expect(logged.length).toBeGreaterThan(0);
+    expectNoSecret(logged.join("\n"));
+  });
+
+  test("a refresh response missing fields never logs the tokens it did carry", async () => {
+    installConfigStore(() => Response.json({}));
+    setFetchForTesting((async () =>
+      Response.json({ access_token: NEW_ACCESS, refresh_token: NEW_REFRESH })) as typeof fetch);
+
+    const reason = await failureOf(loadChatgptSubscriptionCredential(CONFIG));
+
+    expectNoSecret(reason);
+    expectNoSecret(logged.join("\n"));
+  });
+
+  test("a persist failure echoing the rotated tokens is redacted and stays transient", async () => {
+    installConfigStore(
+      () => new Response(`rejected value ${NEW_ACCESS} ${NEW_REFRESH}`, { status: 500 }),
+    );
+    setFetchForTesting((async () =>
+      Response.json({
+        access_token: NEW_ACCESS,
+        refresh_token: NEW_REFRESH,
+        expires_in: 864000,
+      })) as typeof fetch);
+
+    const reason = await failureOf(loadChatgptSubscriptionCredential(CONFIG));
+
+    expect(reason).toContain("HTTP 500");
+    expect(isCodexAuthFailureReason(reason)).toBe(false);
+    expectNoSecret(reason);
+    expectNoSecret(logged.join("\n"));
+  });
+
+  test("a persist fetch rejection echoing the rotated tokens never reaches the reason or logs", async () => {
+    installConfigStore(rejectedPersist);
+    setFetchForTesting((async () =>
+      Response.json({
+        access_token: NEW_ACCESS,
+        refresh_token: NEW_REFRESH,
+        expires_in: 864000,
+      })) as typeof fetch);
+
+    const reason = await failureOf(loadChatgptSubscriptionCredential(CONFIG));
+
+    expect(reason).toContain("Failed to store codex_oauth_0 config: fetch failed");
+    expect(isCodexAuthFailureReason(reason)).toBe(false);
+    expectNoSecret(reason);
+    expectNoSecret(logged.join("\n"));
+  });
+});
+
+describe("persist egress", () => {
+  const rotated: CodexOAuthCredentials = {
+    access: NEW_ACCESS,
+    refresh: NEW_REFRESH,
+    expires: Date.now() + 864000_000,
+    accountId: "acct-egress",
+  };
+
+  test("storeCodexOAuth rethrows a fetch rejection with no token and no raw cause", async () => {
+    globalThis.fetch = (async () => rejectedPersist()) as unknown as typeof fetch;
+
+    let thrown: unknown;
+    try {
+      await storeCodexOAuth(API_URL, "test-key", rotated, 0);
+    } catch (err) {
+      thrown = err;
+    }
+
+    expect(thrown).toBeInstanceOf(Error);
+    const err = thrown as Error;
+    expect(err.message).toContain("fetch failed");
+    expect(err.cause).toBeUndefined();
+    expectNoSecret(Bun.inspect(err));
+  });
+
+  test("persistCodexOAuth logs a fetch rejection or an echoing response without tokens", async () => {
+    globalThis.fetch = (async () => rejectedPersist()) as unknown as typeof fetch;
+    await persistCodexOAuth(API_URL, "test-key", rotated, 0);
+    globalThis.fetch = (async () =>
+      new Response(`rejected value ${NEW_ACCESS} ${NEW_REFRESH}`, { status: 500 })) as typeof fetch;
+    await persistCodexOAuth(API_URL, "test-key", rotated, 0);
+
+    expect(logged.join("\n")).toContain("fetch failed");
+    expect(logged.join("\n")).toContain("HTTP 500");
+    expectNoSecret(logged.join("\n"));
+  });
+});

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

@@ -41,6 +41,13 @@ describe("getContextWindowSize", () => {
     expect(getContextWindowSize("gpt-5")).toBe(400_000);
   });
 
+  test("reads a ChatGPT subscription id's window from its OpenAI id, as codex does", () => {
+    expect(getContextWindowSize("openai-codex/gpt-5.6-luna")).toBe(
+      getContextWindowSize("gpt-5.6-luna"),
+    );
+    expect(getContextWindowSize("openai-codex/gpt-5.6-luna")).not.toBe(200_000);
+  });
+
   test("returns 200K default for unknown models", () => {
     expect(getContextWindowSize("unknown-model")).toBe(200_000);
     expect(getContextWindowSize("")).toBe(200_000);

package/src/tests/explicit-model-validation.test.ts

@@ -331,6 +331,44 @@ describe("grok model namespace", () => {
   });
 });
 
+describe("fx model routes", () => {
+  test("an unrouted namespace, a bare non-OpenAI id or latest:anthropic is refused, even with allowCustomModel", async () => {
+    for (const [model, reason] of [
+      ["nan/glm5.3-flash", "InconsistentFinishReason"],
+      ["helmcode/qwen3.6", "Helmcode is not verified on fx"],
+      ["anthropic/claude-opus-5-5", "Anthropic Messages API"],
+      ["claude-opus-5-5", "is in the anthropic catalog"],
+      ["latest:anthropic/opus", "latest:anthropic alias"],
+    ] as const) {
+      for (const allowCustomModel of [false, true]) {
+        const error = await explicitModelError({ model, harnessProvider: "fx", allowCustomModel });
+        expect(error).toContain(`Model "${model}" does not run on the fx harness`);
+        expect(error).toContain(reason);
+      }
+    }
+  });
+
+  test("the OpenRouter, AI Gateway and OpenAI routes pass", async () => {
+    for (const model of [
+      "openrouter/deepseek/deepseek-v4.1-flash",
+      "vercel/anthropic/claude-opus-5.5",
+      "gpt-5-mini",
+      "latest:openrouter/deepseek/deepseek-v4.1-*",
+    ]) {
+      expect(await explicitModelError({ model, harnessProvider: "fx" })).toBeNull();
+    }
+  });
+
+  test("MODEL_TIER_FX_<TIER> refuses a model fx cannot route", () => {
+    expect(validateTierConfigValue("MODEL_TIER_FX_SMART", "nan/glm5.3-flash")).toContain(
+      'model "nan/glm5.3-flash" does not run on the fx harness',
+    );
+    expect(
+      validateTierConfigValue("MODEL_TIER_FX_SMOL", "openrouter/deepseek/deepseek-v4.1-flash"),
+    ).toBeNull();
+  });
+});
+
 describe("MODEL_TIER_<PROVIDER>_<TIER> values", () => {
   test("a model from another harness family is rejected on write", () => {
     expect(validateTierConfigValue("MODEL_TIER_CODEX_SMART", "claude-opus-5-5")).toBe(
@@ -766,3 +804,64 @@ describe("nan and helmcode catalog models", () => {
     expect(res.status).toBe(200);
   });
 });
+
+describe("ChatGPT subscription models (openai-codex/<id>)", () => {
+  let piId = "";
+
+  beforeAll(async () => {
+    piId = (
+      await createAgent({
+        name: "validation-pi-subscription",
+        isLead: false,
+        status: "idle",
+        harnessProvider: "pi",
+      })
+    ).id;
+  });
+
+  test("known when the bare id is an openai catalog model", () => {
+    const catalog = { openai: { models: { "gpt-5.6-sol": {} } } };
+    expect(isKnownCatalogModel("openai-codex/gpt-5.6-sol", catalog)).toBe(true);
+    expect(isKnownCatalogModel("openai-codex/gpt-9", catalog)).toBe(false);
+    expect(isKnownCatalogModel("openai-codex/openai/gpt-5.6-sol", catalog)).toBe(false);
+  });
+
+  test("pi takes it; opencode, codex, claude and grok get a mismatch", async () => {
+    const model = "openai-codex/gpt-5.6-sol";
+    expect(await explicitModelError({ model, harnessProvider: "pi" })).toBeNull();
+    for (const harnessProvider of ["opencode", "codex", "claude", "grok"]) {
+      const error = await explicitModelError({ model, harnessProvider, allowCustomModel: true });
+      expect(error).toContain(`does not run on the ${harnessProvider} harness`);
+    }
+    expect(await explicitModelError({ model, harnessProvider: "codex" })).toContain(
+      'On codex, use "gpt-5.6-sol"',
+    );
+  });
+
+  test("send-task to a pi agent and the agent runtime PATCH accept it", async () => {
+    const sender = ownerCtx({ agentId: leadId });
+    const accepted = await sendTaskHandler(sender, {
+      task: "run on the chatgpt subscription",
+      offerMode: false,
+      allowDuplicate: false,
+      agentId: piId,
+      model: "openai-codex/gpt-5.6-sol",
+      routingReason: "human_pinned",
+      routingNote: "pinned to check the subscription model id",
+    });
+    expect({ ok: accepted.ok, message: accepted.message }).toEqual({
+      ok: true,
+      message: expect.any(String),
+    });
+
+    const res = await api("PATCH", `/api/agents/${piId}/runtime`, {
+      harness_provider: "pi",
+      model: "openai-codex/gpt-5.6-sol",
+      reasoning_effort: "high",
+    });
+    expect({ status: res.status, body: res.body }).toEqual({
+      status: 200,
+      body: expect.anything(),
+    });
+  });
+});

package/src/tests/extensions-run-context.test.ts

@@ -24,6 +24,17 @@ describe("runContext", () => {
     expect(context.subject?.includes("sk-ant-")).toBe(false);
   });
 
+  test("steering records its source and sender agent without message content", () => {
+    expect(
+      runContext("pre.task.steer", {
+        task: { id: "task-1", agentId: "worker", task: "Private task" },
+        source: "mcp",
+        sender: { kind: "agent", agentId: "lead" },
+        message: "Private correction",
+      }),
+    ).toEqual({ agentId: "lead", subject: "mcp: task task-1" });
+  });
+
   test("post task events record the task's agent", () => {
     expect(
       runContext("post.task.completed", {

package/src/tests/extensions-steering.test.ts

@@ -0,0 +1,353 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { createServer, type Server } from "node:http";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createUser,
+  getChildTasks,
+  getDbClient,
+  getKv,
+  getLogsByTaskId,
+  getSteeringMessagesForTask,
+  getTaskById,
+  initDb,
+  pauseTask,
+  startTask,
+} from "../be/db";
+import { getExtensionByName, installExtension, listExtensionRuns } from "../be/extensions/db";
+import { requestSteering, SteeringBlockedError } from "../be/steering";
+import type { TaskSteerEvent } from "../extensions/contract";
+import { enableExtension, stopExtensionRuntime } from "../extensions/lifecycle";
+import { handleMcpBridge } from "../http/mcp-bridge";
+import { handleTasks } from "../http/tasks";
+import { SwarmConfig } from "../scripts-runtime/swarm-config";
+import { createSwarmSdk } from "../scripts-runtime/swarm-sdk";
+import * as slackApp from "../slack/app";
+import { requestSlackThreadSteering } from "../slack/steering";
+import { bufferThreadMessage, instantFlush } from "../slack/thread-buffer";
+import { steerTaskHandler } from "../tools/steer-task";
+import { ownerCtx } from "../tools/task-tool-ctx";
+import { loadBundleFixture } from "./fixtures/extensions/load";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = `./test-extensions-steering-${process.pid}.sqlite`;
+const ENV_KEYS = [
+  "STEERING_ENABLED",
+  "SLACK_THREAD_STEERING",
+  "SLACK_THREAD_STEERING_MODE",
+  "SLACK_RENDER_V2",
+];
+const savedEnv = new Map(ENV_KEYS.map((key) => [key, process.env[key]]));
+let leadId: string;
+let server: Server;
+let baseUrl: string;
+
+async function removeDbFiles() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await Bun.file(TEST_DB_PATH + suffix)
+      .delete()
+      .catch(() => {});
+  }
+}
+
+async function installPolicy(config: Record<string, unknown>, name = "steering-policy") {
+  const bundle = await loadBundleFixture("steering-policy");
+  const installed = await installExtension({
+    ...bundle,
+    manifest: { ...bundle.manifest, name },
+    config,
+  });
+  return await enableExtension(installed.extension.id);
+}
+
+async function runningTask() {
+  const task = await createTaskExtended("Existing task", {
+    agentId: leadId,
+    source: "slack",
+    slackChannelId: "C_STEER_POLICY",
+    slackThreadTs: "1000.0001",
+  });
+  await startTask(task.id);
+  return task;
+}
+
+async function lastEvent(name = "steering-policy"): Promise<TaskSteerEvent | undefined> {
+  const extension = await getExtensionByName(name);
+  return (await getKv(`task:agent:${extension?.agentId}`, `ext:${name}:last`))?.value as
+    | TaskSteerEvent
+    | undefined;
+}
+
+async function expectNoSteering(taskId: string) {
+  expect(await getSteeringMessagesForTask(taskId)).toEqual([]);
+  expect(
+    (await getLogsByTaskId(taskId)).filter((log) => log.eventType === "task_steering"),
+  ).toEqual([]);
+  expect(await getChildTasks(taskId)).toEqual([]);
+}
+
+describe("extension steering boundary", () => {
+  beforeAll(async () => {
+    process.env.STEERING_ENABLED = "true";
+    process.env.SLACK_THREAD_STEERING = "lead";
+    process.env.SLACK_THREAD_STEERING_MODE = "queue";
+    process.env.SLACK_RENDER_V2 = "false";
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+    server = createServer(async (req, res) => {
+      res.setHeader("Content-Type", "application/json");
+      const path = new URL(req.url ?? "/", "http://localhost").pathname.split("/").filter(Boolean);
+      if (await handleMcpBridge(req, res, path, new URLSearchParams(), leadId)) return;
+      await handleTasks(req, res, path, new URLSearchParams(), leadId);
+    });
+    baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+  });
+
+  beforeEach(async () => {
+    await stopExtensionRuntime();
+    const client = getDbClient();
+    await client.run("DELETE FROM agent_tasks");
+    await client.run("DELETE FROM extensions");
+    await client.run("DELETE FROM kv_entries WHERE key LIKE 'ext:%'");
+    await client.run("DELETE FROM agents");
+    leadId = (
+      await createAgent({
+        name: "Steering policy lead",
+        isLead: true,
+        status: "busy",
+        maxTasks: 10,
+        harnessProvider: "pi",
+      })
+    ).id;
+  });
+
+  afterAll(async () => {
+    await stopExtensionRuntime();
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    await removeDbFiles();
+    for (const [key, value] of savedEnv) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  });
+
+  test("continue records the task, source, mode and sender before queuing the original text", async () => {
+    await installPolicy({ action: "continue" });
+    const task = await runningTask();
+    const result = await requestSteering({
+      taskId: task.id,
+      message: "Add the charts",
+      mode: "steer",
+      source: "mcp",
+      createdByKind: "agent",
+      createdByAgentId: leadId,
+    });
+    expect(result.outcome).toBe("steered");
+    expect(await lastEvent()).toMatchObject({
+      task: { id: task.id, status: "in_progress" },
+      message: "Add the charts",
+      mode: "steer",
+      source: "mcp",
+      sender: { kind: "agent", agentId: leadId },
+    });
+    expect((await getSteeringMessagesForTask(task.id))[0]?.body).toBe("Add the charts");
+  });
+
+  test("valid modifications flow through successive handlers and are the only text delivered", async () => {
+    await installPolicy({ action: "modify", prefix: "first: " });
+    await installPolicy({ action: "modify", prefix: "second: " }, "steering-policy-z");
+    const task = await runningTask();
+    await requestSteering({ taskId: task.id, message: "Add the charts" });
+    expect((await lastEvent("steering-policy-z"))?.message).toBe("first: Add the charts");
+    expect((await getSteeringMessagesForTask(task.id))[0]?.body).toBe(
+      "second: first: Add the charts",
+    );
+  });
+
+  test("block returns an actionable refusal without steering rows, logs or follow-up tasks", async () => {
+    const extension = await installPolicy({ action: "block" });
+    const task = await runningTask();
+    try {
+      await requestSteering({ taskId: task.id, message: "Do not deliver" });
+      throw new Error("Expected steering to be blocked");
+    } catch (error) {
+      expect(error).toBeInstanceOf(SteeringBlockedError);
+      expect(error).toMatchObject({
+        statusCode: 403,
+        extension: { id: extension.id },
+        reason: "Steering denied by policy",
+      });
+    }
+    await expectNoSteering(task.id);
+    expect((await listExtensionRuns(extension.id)).map((run) => run.action)).toEqual(["block"]);
+  });
+
+  test("a blocked paused task is not resumed", async () => {
+    await installPolicy({ action: "block" });
+    const task = await runningTask();
+    await pauseTask(task.id);
+    await expect(
+      requestSteering({ taskId: task.id, message: "Do not resume" }),
+    ).rejects.toBeInstanceOf(SteeringBlockedError);
+    expect((await getTaskById(task.id))?.status).toBe("paused");
+    await expectNoSteering(task.id);
+  });
+
+  for (const action of ["empty", "retarget", "throw"]) {
+    test(`${action} fails open and records an extension error`, async () => {
+      const extension = await installPolicy({ action });
+      const task = await runningTask();
+      await requestSteering({ taskId: task.id, message: "Keep the original" });
+      expect((await getSteeringMessagesForTask(task.id))[0]?.body).toBe("Keep the original");
+      expect((await listExtensionRuns(extension.id))[0]?.action).toBe("error");
+    });
+  }
+
+  test("valid rewritten text is secret-scrubbed before storage", async () => {
+    const secret = `sk-ant-${"a".repeat(40)}`;
+    await installPolicy({ action: "modify", prefix: `${secret} ` });
+    const task = await runningTask();
+    await requestSteering({ taskId: task.id, message: "Keep this" });
+    const body = (await getSteeringMessagesForTask(task.id))[0]?.body;
+    expect(body).not.toContain(secret);
+    expect(body).toContain("Keep this");
+  });
+
+  test("extension-originated steering skips its own handler", async () => {
+    const extension = await installPolicy({ action: "block" });
+    const task = await runningTask();
+    await requestSteering({
+      taskId: task.id,
+      message: "From the extension",
+      createdByKind: "agent",
+      createdByAgentId: extension.agentId!,
+    });
+    expect(await lastEvent()).toBeUndefined();
+    expect((await getSteeringMessagesForTask(task.id))[0]?.body).toBe("From the extension");
+  });
+
+  test("HTTP steering returns 403 for a policy block", async () => {
+    await installPolicy({ action: "block" });
+    const task = await runningTask();
+    const response = await fetch(`${baseUrl}/api/tasks/${task.id}/steer`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Agent-ID": leadId },
+      body: JSON.stringify({ message: "Do not deliver" }),
+    });
+    expect(response.status).toBe(403);
+    expect(await response.text()).toContain("Steering denied by policy");
+    await expectNoSteering(task.id);
+  });
+
+  test("MCP steering reports a policy block as a tool error", async () => {
+    await installPolicy({ action: "block" });
+    const task = await runningTask();
+    const result = await steerTaskHandler(ownerCtx({ agentId: leadId }), {
+      taskId: task.id,
+      message: "Do not deliver",
+    });
+    expect(result.ok).toBe(false);
+    expect(result.message).toContain("Steering denied by policy");
+    expect(await lastEvent()).toMatchObject({ source: "mcp" });
+    await expectNoSteering(task.id);
+  });
+
+  test("script SDK steering reaches the hook through the bridge with the script source", async () => {
+    await installPolicy({ action: "continue" });
+    const task = await runningTask();
+    const sdk = createSwarmSdk(
+      new SwarmConfig({
+        system: {
+          apiKey: { value: "steering-sdk-test-key", isSecret: true },
+          agentId: { value: leadId, isSecret: false },
+          mcpBaseUrl: { value: baseUrl, isSecret: false },
+        },
+        user: {},
+      }),
+    );
+
+    const result = await sdk.task_steer({ taskId: task.id, message: "From the script SDK" });
+
+    expect(result).toMatchObject({
+      success: true,
+      status: 200,
+      data: { success: true, outcome: "queued" },
+    });
+    expect(await lastEvent()).toMatchObject({
+      task: { id: task.id },
+      message: "From the script SDK",
+      mode: "queue",
+      source: "script",
+      sender: { kind: "agent", agentId: leadId },
+    });
+    expect(await getSteeringMessagesForTask(task.id)).toEqual([
+      expect.objectContaining({ source: "script", body: "From the script SDK" }),
+    ]);
+  });
+
+  test("Slack supplies message timestamps and sender metadata without acknowledgement log rows on block", async () => {
+    await installPolicy({ action: "block" });
+    const task = await runningTask();
+    const user = await createUser({ name: "Steering sender" });
+    await expect(
+      requestSlackThreadSteering({
+        channelId: "C_STEER_POLICY",
+        threadTs: "1000.0001",
+        message: "Do not deliver",
+        messageTimestamps: ["1000.0002", "1000.0003"],
+        requestedByUserId: user.id,
+        slackUserId: "U_SENDER",
+      }),
+    ).rejects.toBeInstanceOf(SteeringBlockedError);
+    expect(await lastEvent()).toMatchObject({
+      source: "slack",
+      sender: { kind: "user", userId: user.id },
+      messageTimestamps: ["1000.0002", "1000.0003"],
+      slack: { channelId: "C_STEER_POLICY", threadTs: "1000.0001", userId: "U_SENDER" },
+    });
+    await expectNoSteering(task.id);
+  });
+
+  test("a blocked buffer flush is consumed and later senders still get delivered", async () => {
+    await installPolicy({ action: "block", slackUserId: "U_BLOCKED" });
+    const task = await runningTask();
+    const acked: string[] = [];
+    const posted: string[] = [];
+    const appSpy = spyOn(slackApp, "getSlackApp").mockReturnValue({
+      client: {
+        users: { info: async () => ({ ok: false }) },
+        reactions: {
+          add: async (args: { timestamp: string; name: string }) => {
+            acked.push(`${args.timestamp}:${args.name}`);
+            return { ok: true };
+          },
+          remove: async () => ({ ok: true }),
+        },
+        chat: {
+          postMessage: async (args: { text: string }) => {
+            posted.push(args.text);
+            return { ok: true };
+          },
+        },
+      },
+    } as unknown as NonNullable<ReturnType<typeof slackApp.getSlackApp>>);
+    try {
+      bufferThreadMessage("C_STEER_POLICY", "1000.0001", "Drop this", "U_BLOCKED", "1000.0002");
+      bufferThreadMessage("C_STEER_POLICY", "1000.0001", "Keep this", "U_ALLOWED", "1000.0003");
+      await instantFlush("C_STEER_POLICY:1000.0001");
+      expect((await getSteeringMessagesForTask(task.id)).map((row) => row.body)).toEqual([
+        "Keep this",
+      ]);
+      expect(acked).toContain("1000.0002:no_entry");
+      expect(posted).toHaveLength(1);
+      expect(await getChildTasks(task.id)).toEqual([]);
+      expect(
+        (await getLogsByTaskId(task.id)).filter((log) => log.newValue === "slack_reaction"),
+      ).toEqual([expect.objectContaining({ metadata: expect.stringContaining("1000.0003") })]);
+    } finally {
+      appSpy.mockRestore();
+    }
+  });
+});