@desplega.ai/agent-swarm 1.150.0 → 1.151.0

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

@@ -0,0 +1,431 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
+import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
+import { getExtensionByName, insertExtensionRun, setExtensionState } from "../be/extensions/db";
+import { stopExtensionRuntime } from "../extensions/lifecycle";
+import { handleCore } from "../http/core";
+import { handleExtensions } from "../http/extensions";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import type { User } from "../types";
+import { setRequestAuth } from "../utils/request-auth-context";
+import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
+import { loadBundleFixture } from "./fixtures/extensions/load";
+
+const TEST_DB_PATH = "./test-extensions-http.sqlite";
+const API_KEY = "test-extensions-http-key-1234567890";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await Bun.file(TEST_DB_PATH + suffix)
+      .delete()
+      .catch(() => {});
+  }
+}
+
+type TestResponse = {
+  status: number;
+  text: string;
+  json: () => Promise<Record<string, unknown>>;
+};
+
+async function dispatch(
+  path: string,
+  init: RequestInit & { agentId?: string; asUser?: string } = {},
+): Promise<TestResponse> {
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${API_KEY}`,
+    "Content-Type": "application/json",
+    ...((init.headers as Record<string, string>) ?? {}),
+  };
+  if (init.agentId) headers["X-Agent-ID"] = init.agentId;
+  const req = Readable.from(init.body ? [Buffer.from(String(init.body))] : []) as IncomingMessage;
+  req.method = init.method ?? "GET";
+  req.url = path;
+  req.headers = Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]),
+  );
+
+  let status = 200;
+  let text = "";
+  const res = {
+    headersSent: false,
+    writableEnded: false,
+    setHeader() {},
+    writeHead(code: number) {
+      status = code;
+      this.headersSent = true;
+      return this;
+    },
+    end(chunk?: unknown) {
+      if (chunk !== undefined) text += String(chunk);
+      this.writableEnded = true;
+      return this;
+    },
+  } as unknown as ServerResponse;
+
+  const agentId = req.headers["x-agent-id"] as string | undefined;
+  if (!(await handleCore(req, res, agentId, API_KEY))) {
+    if (init.asUser) {
+      setRequestAuth(req, { kind: "user", userId: init.asUser, user: { id: init.asUser } as User });
+    }
+    const pathSegments = getPathSegments(path);
+    const queryParams = parseQueryParams(path);
+    if (!(await handleExtensions(req, res, pathSegments, queryParams, agentId))) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  }
+
+  return {
+    status,
+    text,
+    json: async () => JSON.parse(text) as Record<string, unknown>,
+  };
+}
+
+async function install(name = "minimal", agentId?: string): Promise<TestResponse> {
+  return dispatch("/api/extensions/install", {
+    method: "POST",
+    agentId,
+    body: JSON.stringify(await loadBundleFixture(name)),
+  });
+}
+
+let leadId: string;
+let workerId: string;
+let savedEnv: NodeJS.ProcessEnv;
+
+beforeAll(async () => {
+  savedEnv = { ...process.env };
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
+  delete process.env.API_KEY;
+  refreshSecretScrubberCache();
+  leadId = (await createAgent({ name: "extensions-lead", isLead: true, status: "idle" })).id;
+  workerId = (await createAgent({ name: "extensions-worker", isLead: false, status: "idle" })).id;
+});
+
+afterAll(async () => {
+  await stopExtensionRuntime();
+  closeDb();
+  await removeDbFiles();
+  for (const key of Object.keys(process.env)) {
+    if (!(key in savedEnv)) delete process.env[key];
+  }
+  Object.assign(process.env, savedEnv);
+  refreshSecretScrubberCache();
+});
+
+beforeEach(async () => {
+  await stopExtensionRuntime();
+  await getDbClient().run("DELETE FROM extensions");
+});
+
+describe("/api/extensions HTTP", () => {
+  test("operator install, list, get, versions, and changed hooks round-trip", async () => {
+    const first = await install();
+    expect(first.status).toBe(200);
+    const firstBody = await first.json();
+    const extension = firstBody.extension as { id: string; version: number };
+    expect(extension.version).toBe(1);
+
+    const list = await dispatch("/api/extensions");
+    expect(list.status).toBe(200);
+    expect((await list.json()).extensions).toHaveLength(1);
+
+    const detail = await dispatch(`/api/extensions/${extension.id}`);
+    expect(detail.status).toBe(200);
+    const detailBody = await detail.json();
+    expect((detailBody.manifest as { name: string }).name).toBe("minimal");
+    expect((detailBody.files as Record<string, string>)["hooks.ts"]).toContain("SwarmExtension");
+
+    const changedBundle = await loadBundleFixture("minimal");
+    changedBundle.files["hooks.ts"] += "\n// changed hooks\n";
+    const changed = await dispatch("/api/extensions/install", {
+      method: "POST",
+      body: JSON.stringify(changedBundle),
+    });
+    expect(changed.status).toBe(200);
+    expect(((await changed.json()).extension as { version: number }).version).toBe(2);
+
+    const versions = await dispatch(`/api/extensions/${extension.id}/versions`);
+    expect(versions.status).toBe(200);
+    expect((await versions.json()).versions).toHaveLength(2);
+  });
+
+  test("GET runs returns both rows newest-first", async () => {
+    await install();
+    const extension = await getExtensionByName("minimal");
+    const first = await insertExtensionRun({
+      extensionId: extension!.id,
+      version: 1,
+      event: "pre.task.create",
+      action: "continue",
+      message: "First run",
+    });
+    const second = await insertExtensionRun({
+      extensionId: extension!.id,
+      version: 1,
+      event: "post.task.created",
+      action: "continue",
+      message: "Second run",
+    });
+
+    const response = await dispatch(`/api/extensions/${extension!.id}/runs`);
+    expect(response.status).toBe(200);
+    expect((await response.json()).runs).toEqual([second, first]);
+  });
+
+  test("lead agents may install, workers may not, and agent installs stay disabled", async () => {
+    expect((await install("minimal", workerId)).status).toBe(403);
+    const response = await install("minimal", leadId);
+    expect(response.status).toBe(200);
+    const extension = (await response.json()).extension as {
+      enabled: boolean;
+      createdByAgentId: string | null;
+    };
+    expect(extension.enabled).toBe(false);
+    expect(extension.createdByAgentId).toBe(leadId);
+  });
+
+  test("operator reinstall activates a new version when the extension is enabled", async () => {
+    await install();
+    const existing = await getExtensionByName("minimal");
+    await setExtensionState(existing!.id, { enabled: true, status: "enabled" });
+
+    const changedBundle = await loadBundleFixture("minimal");
+    changedBundle.files["hooks.ts"] += "\n// operator update\n";
+    const response = await dispatch("/api/extensions/install", {
+      method: "POST",
+      body: JSON.stringify(changedBundle),
+    });
+
+    expect(response.status).toBe(200);
+    const extension = (await response.json()).extension as {
+      version: number;
+      activeVersion: number;
+      enabled: boolean;
+    };
+    expect(extension).toMatchObject({ version: 2, activeVersion: 2, enabled: true });
+  });
+
+  test("lead reinstall never activates a new version", async () => {
+    await install();
+    const existing = await getExtensionByName("minimal");
+    await setExtensionState(existing!.id, { enabled: true, status: "enabled" });
+
+    const changedBundle = await loadBundleFixture("minimal");
+    changedBundle.files["hooks.ts"] += "\n// lead update\n";
+    const response = await dispatch("/api/extensions/install", {
+      method: "POST",
+      agentId: leadId,
+      body: JSON.stringify(changedBundle),
+    });
+
+    expect(response.status).toBe(200);
+    const extension = (await response.json()).extension as {
+      version: number;
+      activeVersion: number;
+      enabled: boolean;
+    };
+    expect(extension).toMatchObject({ version: 2, activeVersion: 1, enabled: true });
+  });
+
+  test("PATCH updates priority and DELETE rejects enabled extensions", async () => {
+    await install();
+    const extension = await getExtensionByName("minimal");
+    expect(extension).not.toBeNull();
+
+    const patched = await dispatch(`/api/extensions/${extension!.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ priority: 10 }),
+    });
+    expect(patched.status).toBe(200);
+    expect(((await patched.json()).extension as { priority: number }).priority).toBe(10);
+
+    await setExtensionState(extension!.id, { enabled: true, status: "enabled" });
+    const rejected = await dispatch(`/api/extensions/${extension!.id}`, { method: "DELETE" });
+    expect(rejected.status).toBe(409);
+    expect((await rejected.json()).error).toContain("Disable");
+  });
+
+  test("type definitions are plain text and activation routes are operator-only", async () => {
+    await install();
+    const extension = await getExtensionByName("minimal");
+    const types = await dispatch("/api/extensions/type-defs");
+    expect(types.status).toBe(200);
+    expect(types.text).toContain('declare module "swarm-extension"');
+
+    expect(
+      (
+        await dispatch(`/api/extensions/${extension!.id}/enable`, {
+          method: "POST",
+          agentId: leadId,
+        })
+      ).status,
+    ).toBe(403);
+    expect(
+      (await dispatch(`/api/extensions/${extension!.id}/enable`, { method: "POST" })).status,
+    ).toBe(200);
+    expect(
+      (await dispatch(`/api/extensions/${extension!.id}/disable`, { method: "POST" })).status,
+    ).toBe(200);
+    expect(
+      (
+        await dispatch(`/api/extensions/${extension!.id}/activate-version`, {
+          method: "POST",
+          body: JSON.stringify({ version: 1 }),
+        })
+      ).status,
+    ).toBe(200);
+  });
+
+  test("dashboard users can install and activate extensions", async () => {
+    const installed = await install("minimal", undefined);
+    expect(installed.status).toBe(200);
+    const extension = await getExtensionByName("minimal");
+    const patched = await dispatch(`/api/extensions/${extension!.id}`, {
+      method: "PATCH",
+      asUser: "user-1",
+      body: JSON.stringify({ priority: 7 }),
+    });
+    expect(patched.status).toBe(200);
+    expect(
+      (
+        await dispatch(`/api/extensions/${extension!.id}/enable`, {
+          method: "POST",
+          asUser: "user-1",
+        })
+      ).status,
+    ).toBe(200);
+  });
+
+  test("enable returns 400 for config that fails the hooks schema", async () => {
+    const bundle = await loadBundleFixture("minimal");
+    bundle.manifest = { ...bundle.manifest, name: "configured" };
+    bundle.files["hooks.ts"] = `
+import { z } from "zod";
+import type { SwarmExtension } from "swarm-extension";
+export const config = z.object({ channelId: z.string() });
+const extension: SwarmExtension = () => {};
+export default extension;
+`;
+    const installed = await dispatch("/api/extensions/install", {
+      method: "POST",
+      body: JSON.stringify(bundle),
+    });
+    const extension = (await installed.json()).extension as { id: string };
+
+    const invalid = await dispatch(`/api/extensions/${extension.id}/enable`, { method: "POST" });
+    expect(invalid.status).toBe(400);
+    expect((await invalid.json()).error).toContain("config is invalid");
+
+    expect(
+      (
+        await dispatch(`/api/extensions/${extension.id}`, {
+          method: "PATCH",
+          body: JSON.stringify({ config: { channelId: "C1" } }),
+        })
+      ).status,
+    ).toBe(200);
+    expect(
+      (await dispatch(`/api/extensions/${extension.id}/enable`, { method: "POST" })).status,
+    ).toBe(200);
+  });
+
+  test("configJson is scrubbed on every read path", async () => {
+    process.env.EXT_QA_TOKEN = "extqaTOKENvalue_1234567890abcdef";
+    refreshSecretScrubberCache();
+    try {
+      const bundle = await loadBundleFixture("minimal");
+      const installed = await dispatch("/api/extensions/install", {
+        method: "POST",
+        body: JSON.stringify({
+          ...bundle,
+          config: { token: "extqaTOKENvalue_1234567890abcdef", other: "a" },
+        }),
+      });
+      expect(installed.status).toBe(200);
+      const extension = await getExtensionByName("minimal");
+      expect(extension!.configJson).toContain("extqaTOKENvalue_1234567890abcdef");
+      for (const body of [
+        await installed.json(),
+        await (await dispatch(`/api/extensions/${extension!.id}`)).json(),
+        await (
+          await dispatch(`/api/extensions/${extension!.id}`, {
+            method: "PATCH",
+            body: JSON.stringify({ priority: 3 }),
+          })
+        ).json(),
+      ]) {
+        expect(JSON.stringify(body)).not.toContain("extqaTOKENvalue_1234567890abcdef");
+        expect(JSON.stringify(body)).toContain("[REDACTED:EXT_QA_TOKEN]");
+      }
+      const list = JSON.stringify(await (await dispatch("/api/extensions")).json());
+      expect(list).not.toContain("extqaTOKENvalue_1234567890abcdef");
+
+      const patched = await dispatch(`/api/extensions/${extension!.id}`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          config: { token: "[REDACTED:EXT_QA_TOKEN]", other: "b" },
+        }),
+      });
+      expect(patched.status).toBe(200);
+      expect(JSON.parse((await getExtensionByName("minimal"))!.configJson)).toEqual({
+        token: "extqaTOKENvalue_1234567890abcdef",
+        other: "b",
+      });
+
+      // Nested objects, arrays, and structural (lowercase) markers survive a round trip.
+      const ghToken = "ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+      const nested = await dispatch(`/api/extensions/${extension!.id}`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          config: {
+            token: "extqaTOKENvalue_1234567890abcdef",
+            github: { token: ghToken, list: [ghToken, "plain"] },
+          },
+        }),
+      });
+      expect(nested.status).toBe(200);
+      const nestedBody = JSON.stringify(await nested.json());
+      expect(nestedBody).not.toContain(ghToken);
+      expect(nestedBody).toContain("[REDACTED:github_token]");
+      const roundTrip = await dispatch(`/api/extensions/${extension!.id}`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          config: {
+            token: "[REDACTED:EXT_QA_TOKEN]",
+            github: {
+              token: "[REDACTED:github_token]",
+              list: ["[REDACTED:github_token]", "changed"],
+            },
+          },
+        }),
+      });
+      expect(roundTrip.status).toBe(200);
+      expect(JSON.parse((await getExtensionByName("minimal"))!.configJson)).toEqual({
+        token: "extqaTOKENvalue_1234567890abcdef",
+        github: { token: ghToken, list: [ghToken, "changed"] },
+      });
+    } finally {
+      delete process.env.EXT_QA_TOKEN;
+      refreshSecretScrubberCache();
+    }
+  });
+
+  test("invalid fixtures return readable diagnostics", async () => {
+    const expected = [
+      ["bad-import", "node:fs"],
+      ["worker-runtime", 'runtime "worker" is not supported in v1'],
+      ["reserved-assets", "assets.skills is not supported in v1"],
+    ];
+    for (const [fixture, diagnostic] of expected) {
+      const response = await install(fixture);
+      expect(response.status).toBe(400);
+      expect(((await response.json()).diagnostics as string[]).join("\n")).toContain(diagnostic!);
+    }
+  });
+});

package/src/tests/extensions-lead-equivalence.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { can } from "@/rbac/can";
+import {
+  grantLeadEquivalence,
+  hasLeadEquivalence,
+  revokeLeadEquivalence,
+} from "@/rbac/elevated-agents";
+
+const extensionAgentId = "11111111-2222-4333-8444-555555555555";
+
+describe("extension agents act with lead privileges while registered", () => {
+  test("lead-only verbs follow the registry", () => {
+    const check = {
+      principal: { kind: "agent" as const, agentId: extensionAgentId, isLead: false },
+      verb: "integration.slack.post" as const,
+      resource: { kind: "none" as const },
+      source: "mcp" as const,
+    };
+    expect(hasLeadEquivalence(extensionAgentId)).toBe(false);
+    expect(can(check).allow).toBe(false);
+
+    grantLeadEquivalence(extensionAgentId);
+    expect(hasLeadEquivalence(extensionAgentId)).toBe(true);
+    expect(can(check).allow).toBe(true);
+    expect(can({ ...check, verb: "extension.write", resource: { kind: "none" } }).allow).toBe(true);
+
+    revokeLeadEquivalence(extensionAgentId);
+    expect(can(check).allow).toBe(false);
+  });
+
+  test("operators and plain workers are unaffected", () => {
+    expect(
+      can({
+        principal: { kind: "agent", agentId: "worker-1", isLead: false },
+        verb: "integration.slack.post",
+        resource: { kind: "none" },
+        source: "mcp",
+      }).allow,
+    ).toBe(false);
+    expect(
+      can({
+        principal: { kind: "operator" },
+        verb: "extension.activate",
+        resource: { kind: "none" },
+        source: "http",
+      }).allow,
+    ).toBe(true);
+  });
+});

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

@@ -0,0 +1,209 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { closeDb, createTaskExtended, getAllAgents, getDbClient, getKv, initDb } from "../be/db";
+import {
+  getExtensionById,
+  installExtension,
+  listExtensionRuns,
+  setExtensionState,
+} from "../be/extensions/db";
+import { dispatchPre, listRegistered } from "../extensions/dispatcher";
+import {
+  activateVersion,
+  disableExtension,
+  enableExtension,
+  loadEnabledExtensions,
+  stopExtensionRuntime,
+} from "../extensions/lifecycle";
+import type { ExtensionInstallBody } from "../types";
+import { loadBundleFixture } from "./fixtures/extensions/load";
+
+const TEST_DB_PATH = "./test-extensions-lifecycle.sqlite";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await Bun.file(TEST_DB_PATH + suffix)
+      .delete()
+      .catch(() => {});
+  }
+}
+
+async function install(bundle: ExtensionInstallBody) {
+  return (await installExtension(bundle)).extension;
+}
+
+async function waitFor(predicate: () => Promise<boolean>, timeoutMs = 10_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!(await predicate())) {
+    if (Date.now() >= deadline) throw new Error("Timed out while waiting for extension event");
+    await Bun.sleep(20);
+  }
+}
+
+describe("extension lifecycle", () => {
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    await stopExtensionRuntime();
+    closeDb();
+    await removeDbFiles();
+  });
+
+  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");
+  });
+
+  test("enable creates an offline extension agent and disable unregisters", async () => {
+    const extension = await install(await loadBundleFixture("minimal"));
+    const enabled = await enableExtension(extension.id);
+    expect(enabled).toMatchObject({ enabled: true, status: "enabled" });
+    expect(listRegistered().map((loaded) => loaded.record.id)).toEqual([extension.id]);
+
+    const agent = (await getAllAgents()).find((candidate) => candidate.name === "ext:minimal");
+    expect(agent).toMatchObject({
+      id: enabled.agentId,
+      status: "offline",
+      role: "extension",
+      description: "System agent for extension minimal",
+      maxTasks: 0,
+    });
+
+    expect(await disableExtension(extension.id)).toMatchObject({
+      enabled: false,
+      status: "disabled",
+    });
+    expect(listRegistered()).toHaveLength(0);
+  });
+
+  test("activate-version swaps source and reloads an enabled extension", async () => {
+    const bundle = await loadBundleFixture("priority-a");
+    const extension = await install(bundle);
+    await enableExtension(extension.id);
+
+    const versionTwo: ExtensionInstallBody = {
+      manifest: bundle.manifest,
+      files: {
+        "hooks.ts": `
+import { block, type SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => block("version two"));
+};
+export default extension;
+`,
+      },
+    };
+    await installExtension(versionTwo);
+
+    expect(await activateVersion(extension.id, 2)).toMatchObject({
+      activeVersion: 2,
+      enabled: true,
+    });
+    expect(
+      await dispatchPre("pre.task.create", {
+        options: {},
+        description: "start",
+        origin: "rest",
+      }),
+    ).toMatchObject({ action: "block", reason: "version two" });
+
+    expect(await activateVersion(extension.id, 1)).toMatchObject({
+      activeVersion: 1,
+      enabled: true,
+    });
+    expect(
+      await dispatchPre("pre.task.create", {
+        options: {},
+        description: "start",
+        origin: "rest",
+      }),
+    ).toEqual({ action: "modify", data: { description: "starta" } });
+  });
+
+  test("boot loads enabled rows and continues after one load error", async () => {
+    const valid = await install(await loadBundleFixture("post-logger"));
+    const invalidBundle = await loadBundleFixture("minimal");
+    invalidBundle.manifest = { ...invalidBundle.manifest, name: "boot-invalid" };
+    invalidBundle.files["hooks.ts"] = "export const invalid = true;";
+    const invalid = await install(invalidBundle);
+    await setExtensionState(valid.id, { enabled: true, status: "enabled" });
+    await setExtensionState(invalid.id, { enabled: true, status: "enabled" });
+
+    await loadEnabledExtensions();
+
+    expect(listRegistered().map((loaded) => loaded.record.id)).toEqual([valid.id]);
+    expect(await getExtensionById(invalid.id)).toMatchObject({ enabled: true, status: "error" });
+    expect(await listExtensionRuns(invalid.id)).toMatchObject([{ action: "load-error" }]);
+
+    await createTaskExtended("boot-loaded extension test", { source: "api" });
+    await waitFor(async () =>
+      (await listExtensionRuns(valid.id)).some(
+        (run) => run.event === "post.task.created" && run.action === "continue",
+      ),
+    );
+  });
+
+  test("the post bridge dispatches post.task.created after commit", async () => {
+    const extension = await install(await loadBundleFixture("post-logger"));
+    const enabled = await enableExtension(extension.id);
+    await createTaskExtended("extension post bridge test", { source: "api" });
+
+    await waitFor(async () =>
+      (await listExtensionRuns(extension.id)).some(
+        (run) => run.event === "post.task.created" && run.action === "continue",
+      ),
+    );
+    expect(await getExtensionById(extension.id)).toMatchObject({
+      enabled: true,
+      consecutiveFailures: 0,
+    });
+    expect(await getKv(`task:agent:${enabled.agentId}`, "ext:post-logger:created")).toMatchObject({
+      value: 1,
+    });
+  });
+
+  test("five post handler failures auto-disable and re-enable resets the counter", async () => {
+    const extension = await install(await loadBundleFixture("throws"));
+    await enableExtension(extension.id);
+
+    for (let index = 0; index < 5; index += 1) {
+      await createTaskExtended(`throwing extension test ${index}`, { source: "api" });
+      await waitFor(
+        async () => (await getExtensionById(extension.id))!.consecutiveFailures > index,
+      );
+    }
+
+    expect(await getExtensionById(extension.id)).toMatchObject({
+      enabled: false,
+      status: "auto-disabled",
+      consecutiveFailures: 5,
+    });
+    expect(listRegistered()).toHaveLength(0);
+    expect(await enableExtension(extension.id)).toMatchObject({
+      enabled: true,
+      status: "enabled",
+      consecutiveFailures: 0,
+    });
+  });
+
+  test("the post bridge skips the extension that created a task", async () => {
+    const first = await install(await loadBundleFixture("post-logger"));
+    const secondBundle = await loadBundleFixture("post-logger");
+    secondBundle.manifest = { ...secondBundle.manifest, name: "other-logger" };
+    const second = await install(secondBundle);
+    const creator = await enableExtension(first.id);
+    await enableExtension(second.id);
+    await createTaskExtended("extension-created task", {
+      source: "api",
+      creatorAgentId: creator.agentId!,
+    });
+    await waitFor(async () => (await listExtensionRuns(second.id)).length > 0);
+    expect(await listExtensionRuns(first.id)).toEqual([]);
+    expect(await listExtensionRuns(second.id)).toMatchObject([{ action: "continue" }]);
+  });
+});