@desplega.ai/agent-swarm 2.5.3 → 2.6.0

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

@@ -2,9 +2,14 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:
 import {
   CREDENTIAL_RETRY_INTERVAL_MS,
   type CredentialRefreshState,
+  credentialFingerprint,
+  KEY_RECHECK_INTERVAL_MS,
+  recheckableFailures,
   refreshCredentialStatus,
+  reportKeyValidation,
 } from "../commands/credential-refresh";
 import * as credentials from "../commands/provider-credentials";
+import { fetchResolvedEnv } from "../commands/runner";
 import type { AgentCredStatus } from "../types";
 
 const api = { apiUrl: "http://unused.test", apiKey: "test", agentId: crypto.randomUUID() };
@@ -27,7 +32,14 @@ describe("runner credential refresh", () => {
   let send: ReturnType<typeof spyOn<typeof credentials, "sendCredStatusReport">>;
 
   beforeEach(() => {
-    state = { harnessProvider: "claude", ready: true, lastRefreshAt: 0, inFlight: false };
+    state = {
+      harnessProvider: "claude",
+      ready: true,
+      lastRefreshAt: 0,
+      inFlight: false,
+      fingerprint: credentialFingerprint({}),
+      rejectedKeys: 0,
+    };
     build = spyOn(credentials, "buildCredStatusReport").mockResolvedValue(ready);
     send = spyOn(credentials, "sendCredStatusReport").mockResolvedValue(undefined);
   });
@@ -43,6 +55,136 @@ describe("runner credential refresh", () => {
     expect(state.ready).toBe(true);
   });
 
+  test("a changed credential fingerprint refreshes a ready worker immediately", async () => {
+    const env = { ANTHROPIC_API_KEY: "test-pool-a,test-pool-b" };
+    await refreshCredentialStatus(api, state, "claude", env, 1);
+    expect(build).toHaveBeenCalledWith("claude", env, {}, "post_task");
+    expect(state.fingerprint).toBe(credentialFingerprint(env));
+    await refreshCredentialStatus(api, state, "claude", env, 2);
+    expect(build).toHaveBeenCalledTimes(1);
+    await refreshCredentialStatus(api, state, "claude", {}, 3);
+    expect(build).toHaveBeenCalledTimes(2);
+  });
+
+  test("an unchanged fingerprint does not refresh a ready worker", async () => {
+    await refreshCredentialStatus(api, state, "claude", {}, KEY_RECHECK_INTERVAL_MS);
+    expect(build).not.toHaveBeenCalled();
+  });
+
+  test("fingerprints ignore environment order and unrelated values", () => {
+    expect(credentialFingerprint({ ANTHROPIC_API_KEY: "test-a", PATH: "a" })).toBe(
+      credentialFingerprint({ PATH: "b", ANTHROPIC_API_KEY: "test-a" }),
+    );
+    for (const key of ["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "OPENAI_API_KEY"]) {
+      expect(credentialFingerprint({ [key]: "changed" })).not.toBe(credentialFingerprint({}));
+    }
+  });
+
+  test("resolved credential env preserves the full pool before selection", async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async (url) => {
+      if (String(url).includes("/api/config/resolved")) {
+        return Response.json({
+          configs: [{ key: "ANTHROPIC_API_KEY", value: "test-aaa11,test-bbb22" }],
+        });
+      }
+      return Response.json({ availableIndices: [1], rejectedIndices: [0] });
+    }) as typeof fetch;
+    try {
+      const result = await fetchResolvedEnv(api.apiUrl, api.apiKey, api.agentId, {
+        HARNESS_PROVIDER: "claude",
+      });
+      expect(result.credentialEnv.ANTHROPIC_API_KEY).toBe("test-aaa11,test-bbb22");
+      expect(result.env.ANTHROPIC_API_KEY).toBe("test-bbb22");
+      expect(result.credentialEnv).not.toBe(result.env);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("rejected keys refresh after ten minutes, even when the worker is ready", async () => {
+    state.rejectedKeys = 1;
+    await refreshCredentialStatus(api, state, "claude", {}, KEY_RECHECK_INTERVAL_MS - 1);
+    expect(build).not.toHaveBeenCalled();
+    await refreshCredentialStatus(api, state, "claude", {}, KEY_RECHECK_INTERVAL_MS);
+    expect(build).toHaveBeenCalledTimes(1);
+    expect(state.rejectedKeys).toBe(0);
+  });
+
+  test("a failed live test without per-key results remains eligible for recheck", async () => {
+    build.mockResolvedValueOnce({
+      ...ready,
+      liveTest: { ok: false, error: "timeout", latency_ms: 1 },
+    });
+    await refreshCredentialStatus(api, state, "pi", {}, 1);
+    expect(state.rejectedKeys).toBe(1);
+  });
+
+  test("refresh reports per-key results once per credential type", async () => {
+    const keys = [
+      {
+        keyType: "ANTHROPIC_API_KEY",
+        index: 0,
+        suffix: "aaa11",
+        ok: false,
+        httpStatus: 401,
+        latency_ms: 1,
+      },
+      { keyType: "ANTHROPIC_API_KEY", index: 1, suffix: "bbb22", ok: true, latency_ms: 1 },
+      { keyType: "OPENAI_API_KEY", index: 0, suffix: "ccc33", ok: true, latency_ms: 1 },
+    ];
+    build.mockResolvedValueOnce({ ...ready, liveTest: { ok: false, latency_ms: 1, keys } });
+    const requests: Array<{ url: string; init?: RequestInit }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async (url, init) => {
+      requests.push({ url: String(url), init });
+      return Response.json({ success: true });
+    }) as typeof fetch;
+    try {
+      await refreshCredentialStatus(api, state, "pi", {}, 1);
+      expect(state.rejectedKeys).toBe(1);
+      expect(requests).toHaveLength(2);
+      expect(requests[0]!.url).toBe(`${api.apiUrl}/api/keys/report-validation`);
+      expect(requests[0]!.init?.headers).toMatchObject({
+        Authorization: `Bearer ${api.apiKey}`,
+        "X-Agent-ID": api.agentId,
+      });
+      expect(JSON.parse(String(requests[0]!.init?.body))).toEqual({
+        keyType: "ANTHROPIC_API_KEY",
+        keys: [
+          { keyIndex: 0, keySuffix: "aaa11", ok: false, httpStatus: 401 },
+          { keyIndex: 1, keySuffix: "bbb22", ok: true },
+        ],
+      });
+      expect(JSON.parse(String(requests[1]!.init?.body))).toEqual({
+        keyType: "OPENAI_API_KEY",
+        keys: [{ keyIndex: 0, keySuffix: "ccc33", ok: true }],
+      });
+      expect(requests[0]!.init?.signal).toBeInstanceOf(AbortSignal);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("validation reporting contains HTTP and network failures", async () => {
+    const originalFetch = globalThis.fetch;
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    const fetchMock = mock<typeof fetch>()
+      .mockResolvedValueOnce(new Response(null, { status: 503 }))
+      .mockRejectedValueOnce(new Error("network unavailable"));
+    globalThis.fetch = fetchMock as typeof fetch;
+    try {
+      await reportKeyValidation(api, [
+        { keyType: "ANTHROPIC_API_KEY", index: 0, suffix: "aaa11", ok: true, latency_ms: 1 },
+        { keyType: "OPENAI_API_KEY", index: 0, suffix: "bbb22", ok: true, latency_ms: 1 },
+      ]);
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+      expect(warn).toHaveBeenCalledTimes(2);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
   test("a failed readiness write is throttled and retried even when the snapshot is ready", async () => {
     send.mockRejectedValueOnce(new Error("HTTP 503"));
     await expect(refreshCredentialStatus(api, state, "pi", {}, 1)).rejects.toThrow("HTTP 503");
@@ -113,3 +255,32 @@ describe("runner credential refresh", () => {
     expect(build).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("recheckableFailures", () => {
+  const key = (keyType: string, ok: boolean) => ({
+    keyType,
+    index: 0,
+    suffix: "abcde",
+    ok,
+    latency_ms: 1,
+  });
+
+  test("a Claude subscription token never joins the periodic recheck", () => {
+    const liveTest = {
+      ok: false,
+      error: "rejected",
+      latency_ms: 1,
+      testedAt: 1,
+      keys: [key("CLAUDE_CODE_OAUTH_TOKEN", false), key("ANTHROPIC_API_KEY", false)],
+    };
+    expect(recheckableFailures(liveTest)).toBe(1);
+    expect(
+      recheckableFailures({ ...liveTest, keys: [key("CLAUDE_CODE_OAUTH_TOKEN", false)] }),
+    ).toBe(0);
+  });
+
+  test("a failed test without per-key results counts once", () => {
+    expect(recheckableFailures({ ok: false, error: "x", latency_ms: 1, testedAt: 1 })).toBe(1);
+    expect(recheckableFailures(null)).toBe(0);
+  });
+});

package/src/tests/db-retention.test.ts

@@ -19,8 +19,13 @@ import {
 const TEST_DB_PATH = "./test-db-retention.sqlite";
 const NOW = new Date("2026-08-23T12:00:00.000Z");
 const RETENTION_KEYS = DB_RETENTION_TABLES.map((table) => table.envKey);
-/** Time-horizon tables. Count-based context_versions has its own suite. */
-const AGE_TABLES = DB_RETENTION_TABLES.filter((table) => table.policy === "age");
+/**
+ * Plain time-horizon tables. Count-based context_versions and status-filtered
+ * script_runs have their own suites.
+ */
+const AGE_TABLES = DB_RETENTION_TABLES.filter(
+  (table) => table.policy === "age" && !("terminalStatuses" in table),
+);
 type AgeTable = (typeof AGE_TABLES)[number];
 const TUNING_KEYS = [
   "DB_RETENTION_TICK_BUDGET_MS",
@@ -135,12 +140,13 @@ afterEach(async () => {
 });
 
 describe("DB retention", () => {
-  test("keeps the closed allowlist limited to the four approved tables", () => {
+  test("keeps the closed allowlist limited to the five approved tables", () => {
     expect(DB_RETENTION_TABLES.map((table) => table.table)).toEqual([
       "session_logs",
       "agent_log",
       "events",
       "context_versions",
+      "script_runs",
     ]);
   });
 

package/src/tests/db-task-read-contract.test.ts

@@ -529,6 +529,7 @@ value:recordKeyAuthFailure
 value:recordKeyRateLimitWindows
 value:recordKeySeatMismatch
 value:recordKeyUsage
+value:recordKeyValidation
 value:recordSlackMessage
 value:recordTaskProviderIfUnset
 value:recordTaskPullRequestAttachments

package/src/tests/db-task-write-contract.test.ts

@@ -552,6 +552,7 @@ value:recordKeyAuthFailure
 value:recordKeyRateLimitWindows
 value:recordKeySeatMismatch
 value:recordKeyUsage
+value:recordKeyValidation
 value:recordSlackMessage
 value:recordTaskProviderIfUnset
 value:recordTaskPullRequestAttachments
@@ -684,7 +685,6 @@ STEERING_MESSAGE_SELECT
 UNATTRIBUTED_USER_ID
 VERSIONABLE_FIELDS
 WEEK_SECONDS
-WORKFLOW_RUN_SUMMARY_COLUMNS
 abandonSlackOutcomeDelivery
 acceptTask
 assertSkillFileLimits
@@ -1097,8 +1097,6 @@ rowToUser
 rowToUserFavorite
 rowToWaitState
 rowToWorkflow
-rowToWorkflowRun
-rowToWorkflowRunStep
 rowToWorkflowSummary
 rowToWorkflowVersion
 scriptRunUpdateSets

package/src/tests/docs-index-footprint.test.js

@@ -78,7 +78,7 @@ describe("docs API index footprint", () => {
     expect(tasks).toContain('"path":"/api/task-templates","method":"get"');
   });
 
-  test("OpenAPI and generated pages keep all 449 operations", async () => {
+  test("OpenAPI and generated pages keep all 456 operations", async () => {
     const spec = await Bun.file(resolve(repoRoot, "openapi.json")).json();
     const operationKeys = [];
     const tags = new Set();
@@ -103,8 +103,8 @@ describe("docs API index footprint", () => {
     expect(spec.paths["/api/agents/{id}/runtime"]?.get).toBeDefined();
 
     const generatedKeys = await generatedOperationKeys();
-    expect(operationKeys).toHaveLength(449);
-    expect(generatedKeys).toHaveLength(449);
+    expect(operationKeys).toHaveLength(456);
+    expect(generatedKeys).toHaveLength(456);
     expect(new Set(generatedKeys)).toEqual(new Set(operationKeys));
   });
 

package/src/tests/extensions-pre-task.test.ts

@@ -14,6 +14,7 @@ import {
   createWorkflowRunStep,
   getDbClient,
   getKv,
+  getMostRecentTaskInThread,
   getTaskByWorkflowRunStepId,
   initDb,
   startTask,
@@ -22,9 +23,12 @@ import * as dbClient from "../be/db-client";
 import type { InstallExtensionArgs as ExtensionInstallBody } from "../be/extensions/db";
 import { installExtension, listExtensionRuns } from "../be/extensions/db";
 import { getCatalogEntry } from "../extensions/catalog";
+import type { TaskBlockedEvent, TaskCreateEvent } from "../extensions/contract";
 import { disableExtension, enableExtension, stopExtensionRuntime } from "../extensions/lifecycle";
+import { initExtensionPostBridge, teardownExtensionPostBridge } from "../extensions/post-bridge";
 import { handleTasks } from "../http/tasks";
 import { dispatchScheduleTarget } from "../scheduler/scheduler";
+import { bufferThreadMessage, instantFlush } from "../slack/thread-buffer";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
 import { registerSendTaskTool, sendTaskHandler } from "../tools/send-task";
@@ -145,6 +149,276 @@ describe("extension task boundaries", () => {
     await client.run("DELETE FROM agents");
   });
 
+  describe("post.task.blocked", () => {
+    const events: unknown[] = [];
+    const capture = (event: unknown) => {
+      events.push(event);
+    };
+
+    beforeAll(() => {
+      initExtensionPostBridge();
+      workflowEventBus.on("task.create_blocked", capture);
+    });
+
+    afterAll(() => {
+      workflowEventBus.off("task.create_blocked", capture);
+      teardownExtensionPostBridge();
+    });
+
+    beforeEach(() => {
+      events.length = 0;
+    });
+
+    async function waitForCounter(
+      extension: Awaited<ReturnType<typeof installAndEnable>>,
+      key: string,
+      count = 1,
+    ): Promise<void> {
+      const deadline = Date.now() + 3_000;
+      while (Date.now() < deadline) {
+        const entry = await getKv(`task:agent:${extension.agentId}`, key);
+        if (entry?.value === count) return;
+        await Bun.sleep(10);
+      }
+      throw new Error(`post.task.blocked was not recorded ${count} time(s)`);
+    }
+
+    async function recordedBlock(
+      extension: Awaited<ReturnType<typeof installAndEnable>>,
+      count = 1,
+    ): Promise<TaskBlockedEvent> {
+      await waitForCounter(extension, "ext:record-blocks:count", count);
+      return (await getKv(`task:agent:${extension.agentId}`, "ext:record-blocks:last"))
+        ?.value as TaskBlockedEvent;
+    }
+
+    test.each([
+      "rest",
+      "mcp",
+      "slack",
+      "schedule",
+    ] as const)("%s delivers one blocked event with its source and requester", async (origin) => {
+      const blocker = await installAndEnable("block-tasks-from-source", { source: origin });
+      const recorder = await installAndEnable("record-blocks");
+      let requester: TaskBlockedEvent["requester"] = {};
+      let scheduleId: string | undefined;
+
+      if (origin === "rest") {
+        const user = await createUser({ name: "Blocked REST requester" });
+        requester = { userId: user.id };
+        expect(
+          (await postTask({ task: "blocked REST task", requestedByUserId: user.id })).status,
+        ).toBe(422);
+      } else if (origin === "mcp") {
+        const caller = await createAgent({ name: "blocked-mcp-caller", status: "idle" });
+        requester = { agentId: caller.id };
+        const server = new McpServer({ name: "blocked-event-send", version: "1.0.0" });
+        registerSendTaskTool(server);
+        const result = await registeredSendTask(server).handler(sendTaskArgs("blocked MCP task"), {
+          sessionId: "blocked-event",
+          requestInfo: { headers: { "x-agent-id": caller.id } },
+        });
+        expect(result.isError).toBe(true);
+      } else if (origin === "slack") {
+        requester = { slackUserId: "U_BLOCKED_EVENT" };
+        await createAgent({ name: "blocked-slack-lead", isLead: true, status: "idle" });
+        bufferThreadMessage(
+          "C_BLOCKED_EVENT",
+          "1000.0001",
+          "blocked Slack task",
+          "U_BLOCKED_EVENT",
+          "1000.0002",
+        );
+        await instantFlush("C_BLOCKED_EVENT:1000.0001");
+      } else {
+        const schedule = await createScheduledTask({
+          name: "blocked-event-schedule",
+          taskTemplate: "blocked schedule task",
+          intervalMs: 60_000,
+        });
+        scheduleId = schedule.id;
+        await expect(dispatchScheduleTarget(schedule)).rejects.toThrow(
+          "Task source schedule is blocked",
+        );
+      }
+
+      const event = await recordedBlock(recorder);
+      expect(events).toHaveLength(1);
+      expect(event).toMatchObject({
+        extension: { id: blocker.id, name: "block-tasks-from-source" },
+        origin,
+        source: origin === "rest" ? "api" : origin,
+        requester,
+      });
+      expect(event.requester).toEqual(requester);
+      if (scheduleId) expect(event.context?.scheduleId).toBe(scheduleId);
+      expect(event).not.toHaveProperty("task");
+      expect(event).not.toHaveProperty("taskId");
+    });
+
+    test("scrubs and bounds the payload, preserving correlation on each retry", async () => {
+      const secret = `ghp_${"Z".repeat(36)}`;
+      await installSource(
+        "secret-blocker",
+        `
+import { block, type SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => block(${JSON.stringify(`Ticket required: ${secret}`)}));
+};
+export default extension;
+`,
+      );
+      const recorder = await installAndEnable("record-blocks");
+      const context = {
+        contextKey: "github:acme/project:7",
+        scheduleId: crypto.randomUUID(),
+        workflowRunId: crypto.randomUUID(),
+        workflowRunStepId: crypto.randomUUID(),
+        parentTaskId: crypto.randomUUID(),
+        vcsRepo: "acme/project",
+        vcsNumber: 7,
+        slackChannelId: "C_CORRELATED_BLOCK",
+        slackThreadTs: "2000.0001",
+      };
+      const requester = {
+        userId: crypto.randomUUID(),
+        agentId: crypto.randomUUID(),
+        slackUserId: "U_CORRELATED_BLOCK",
+      };
+      for (const attempt of [1, 2]) {
+        await expect(
+          createTaskWithSiblingAwareness(
+            `${"x".repeat(480)} ${secret}`,
+            {
+              ...context,
+              source: "github",
+              requestedByUserId: requester.userId,
+              creatorAgentId: requester.agentId,
+              slackUserId: requester.slackUserId,
+            },
+            { origin: "webhook" },
+          ),
+        ).rejects.toThrow("Ticket required:");
+        const event = await recordedBlock(recorder, attempt);
+        expect(events).toHaveLength(attempt);
+        expect(event.reason).toContain("[REDACTED:");
+        expect(event.reason).not.toContain(secret);
+        expect(event.description).toHaveLength(500);
+        expect(event.description).not.toContain("ghp_");
+        expect(event.context).toEqual(context);
+        expect(event.requester).toEqual(requester);
+      }
+    });
+
+    test("a rejected model rewrite emits a block attributed to its editor", async () => {
+      const codex = await createAgent({
+        name: "blocked-rewrite-codex",
+        harnessProvider: "codex",
+        status: "idle",
+      });
+      const editor = await installSource(
+        "incompatible-model",
+        `
+import { modify, type SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => modify({ model: "claude-opus-5-5" }));
+};
+export default extension;
+`,
+      );
+      const recorder = await installAndEnable("record-blocks");
+      const result = await postTask({
+        task: "incompatible rewrite",
+        agentId: codex.id,
+        routingReason: "human_pinned",
+      });
+      expect(result.status).toBe(422);
+      const event = await recordedBlock(recorder);
+      expect(events).toHaveLength(1);
+      expect(event.extension).toEqual({ id: editor.id, name: "incompatible-model" });
+      expect(event.reason).toContain("rewrite");
+      expect(event.reason).toContain("codex");
+    });
+
+    test("the creator is skipped while the blocking extension receives its own block", async () => {
+      const creator = await installAndEnable("record-blocks");
+      const blocker = await installSource(
+        "blocking-recorder",
+        `
+import { block, type SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => block("blocked by recorder"));
+  api.on("post.task.blocked", async (_event, ctx) => { await ctx.state.incr("count"); });
+};
+export default extension;
+`,
+      );
+      const observerBundle = await loadBundleFixture("record-blocks");
+      const installedObserver = await installExtension({
+        ...observerBundle,
+        manifest: { ...observerBundle.manifest, name: "last-block-observer" },
+        priority: 1_000,
+      });
+      const observer = await enableExtension(installedObserver.extension.id);
+      const server = new McpServer({ name: "extension-blocked-event", version: "1.0.0" });
+      registerSendTaskTool(server);
+      const result = await registeredSendTask(server).handler(
+        sendTaskArgs("extension task"),
+        markExtensionRequestOrigin({
+          sessionId: "blocked-extension",
+          requestInfo: { headers: { "x-agent-id": creator.agentId! } },
+        }),
+      );
+      expect(result.isError).toBe(true);
+      // The final subscriber acknowledges only after every earlier recipient has finished.
+      await waitForCounter(observer, "ext:last-block-observer:count");
+      expect(
+        (await getKv(`task:agent:${blocker.agentId}`, "ext:blocking-recorder:count"))?.value,
+      ).toBe(1);
+      expect(events).toHaveLength(1);
+      expect(events[0]).toMatchObject({ origin: "extension:record-blocks" });
+      expect(await getKv(`task:agent:${creator.agentId}`, "ext:record-blocks:count")).toBeNull();
+      expect(await listExtensionRuns(creator.id)).toEqual([]);
+      const runs = await listExtensionRuns(blocker.id);
+      expect(runs).toContainEqual(
+        expect.objectContaining({
+          event: "post.task.blocked",
+          agentId: creator.agentId,
+          subject: "extension:record-blocks: blocking-recorder",
+        }),
+      );
+    });
+
+    test("continue and valid rewrites emit no blocked event", async () => {
+      const recorder = await installAndEnable("record-blocks");
+      expect((await postTask({ task: "continued task" })).status).toBe(201);
+      await installAndEnable("rewrite-task-priority");
+      const modified = await postTask({ task: "rewritten task" });
+      expect(modified.status).toBe(201);
+      expect(modified.body.priority).toBe(1);
+      expect(events).toEqual([]);
+      expect(await getKv(`task:agent:${recorder.agentId}`, "ext:record-blocks:count")).toBeNull();
+    });
+
+    test("a throwing bus observer does not replace the blocked response", async () => {
+      await installAndEnable("block-tasks-from-source", { source: "rest" });
+      let calls = 0;
+      const observer = () => {
+        calls++;
+        throw new Error("broken block observer");
+      };
+      const error = spyOn(console, "error").mockImplementation(() => {});
+      workflowEventBus.on("task.create_blocked", observer);
+      try {
+        expect((await postTask({ task: "still blocked" })).status).toBe(422);
+        expect(calls).toBe(1);
+      } finally {
+        workflowEventBus.off("task.create_blocked", observer);
+        error.mockRestore();
+      }
+    });
+  });
+
   test("REST task creation applies rewrites and reports blocks as 422", async () => {
     const rewrite = await installAndEnable("rewrite-task-priority");
     const created = await postTask({ task: "rewrite this task" });
@@ -278,6 +552,57 @@ describe("extension task boundaries", () => {
     );
   });
 
+  test("Slack event metadata retains mixed-sender batches and rejects metadata rewrites", async () => {
+    await createAgent({ name: "slack-metadata-lead", isLead: true, status: "idle" });
+    await installSource(
+      "a-rewrite-slack-metadata",
+      `import type { SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => ({ action: "modify", data: {
+    priority: 7, slack: { trigger: "mention", messages: [] }
+  } as never }));
+};
+export default extension;
+`,
+    );
+    const recorder = await installAndEnable("record-task-create");
+    const channelId = "C_EVENT_METADATA";
+    const threadTs = "3000.0001";
+    bufferThreadMessage(channelId, threadTs, "first request", "U_FIRST", "3000.0002");
+    bufferThreadMessage(channelId, threadTs, "second request", "U_SECOND", "3000.0003");
+
+    await instantFlush(`${channelId}:${threadTs}`);
+
+    const event = (await getKv(`task:agent:${recorder.agentId}`, "ext:record-task-create:last"))
+      ?.value as TaskCreateEvent & { slack?: unknown };
+    expect(event.slack).toEqual({
+      trigger: "thread-buffer",
+      messages: [
+        { ts: "3000.0002", userId: "U_FIRST", text: "first request" },
+        { ts: "3000.0003", userId: "U_SECOND", text: "second request" },
+      ],
+    });
+    expect(event.origin).toBe("slack");
+    expect(event.options).toMatchObject({
+      slackTriggerMessageTs: "3000.0003",
+      slackUserId: "U_FIRST",
+      priority: 7,
+    });
+    expect(event.options).not.toHaveProperty("slack");
+    const task = await getMostRecentTaskInThread(channelId, threadTs);
+    expect(task).toMatchObject({
+      priority: 7,
+      slackTriggerMessageTs: "3000.0003",
+      slackUserId: "U_FIRST",
+    });
+    expect(task).not.toHaveProperty("slack");
+
+    await createTaskWithSiblingAwareness("ordinary API task", { source: "api" });
+    const apiEvent = (await getKv(`task:agent:${recorder.agentId}`, "ext:record-task-create:last"))
+      ?.value as TaskCreateEvent & { slack?: unknown };
+    expect(apiEvent).not.toHaveProperty("slack");
+  });
+
   test("scheduler and workflow executor provide their task creation origins", async () => {
     const extension = await installSource(
       "record-task-origin",

package/src/tests/fetch-resolved-env.test.ts

@@ -14,6 +14,7 @@ import {
   fetchResolvedEnv,
   RELOADABLE_ENV_KEYS,
 } from "../commands/runner";
+import { contextBoundNoteThreshold } from "../hooks/context-bound-note";
 import { checkCodexCredentials } from "../providers/codex-adapter";
 import { MASKED_SECRET_VALUE } from "../utils/config-secrets";
 import { registerVolatileSecret } from "../utils/secret-scrubber";
@@ -795,6 +796,22 @@ describe("agent-scoped PI_CODEMODE_MODELS reaches the worker env", () => {
   });
 });
 
+describe("agent-scoped CONTEXT_BOUND_NOTE_TOKENS turns the note on for one agent", () => {
+  // Each session's env is this agent's /api/config/resolved result (global,
+  // then agent, then repo rows), and every adapter reads the threshold from it.
+  test("the agent with the row gets the threshold; an agent without it stays off", async () => {
+    mockResponsesByAgentId.set("bound-note-pilot", {
+      status: 200,
+      body: { configs: [{ key: "CONTEXT_BOUND_NOTE_TOKENS", value: "150000" }] },
+    });
+    const baseEnv: Record<string, string | undefined> = {};
+    const pilot = await fetchResolvedEnv(testUrl, "key", "bound-note-pilot", baseEnv);
+    const other = await fetchResolvedEnv(testUrl, "key", "bound-note-other", baseEnv);
+    expect(contextBoundNoteThreshold(pilot.env)).toBe(150_000);
+    expect(contextBoundNoteThreshold(other.env)).toBe(0);
+  });
+});
+
 describe("deleting a reloadable config row", () => {
   // One key per test: the runner remembers each overridden key's boot value
   // for the life of the process.

package/src/tests/fixtures/extensions/record-blocks/hooks.ts

@@ -0,0 +1,10 @@
+import type { SwarmExtension } from "swarm-extension";
+
+const extension: SwarmExtension = (api) => {
+  api.on("post.task.blocked", async (event, ctx) => {
+    await ctx.state.set("last", event);
+    await ctx.state.incr("count");
+  });
+};
+
+export default extension;