@desplega.ai/agent-swarm 1.131.1 → 1.133.1

package/src/tests/openapi-response-contract.test.ts

@@ -87,6 +87,30 @@ describe("route handle respond()", () => {
     expect(out.status).toBe(200);
     expect(out.body).toBe(JSON.stringify({ n: "not-a-number" }));
   });
+
+  test("fail-open: gate armed outside tests logs the violation and still sends", () => {
+    // Step-6 regression: with the gate armed (VALIDATE_HTTP_RESPONSES=true)
+    // but NODE_ENV != test, a schema violation must not throw — it logs to
+    // stderr and the response still goes out (2026-08-18 incident shape).
+    const probe = `
+      import { z } from "zod";
+      import { route } from "${import.meta.dir}/../http/route-def";
+      const r = route({
+        method: "get", path: "/probe", pattern: ["probe"], summary: "p", tags: ["t"],
+        responses: { 200: { description: "ok", schema: z.object({ n: z.number() }) } },
+      });
+      let status = 0, body = "";
+      r.respond({ writeHead(s) { status = s; return this; }, end(b) { body = b; return this; } }, 200, { n: "not-a-number" });
+      console.log(JSON.stringify({ status, body }));
+    `;
+    const env = { ...process.env, NODE_ENV: "production", VALIDATE_HTTP_RESPONSES: "true" };
+    const proc = Bun.spawnSync(["bun", "-e", probe], { env });
+    expect(proc.exitCode).toBe(0);
+    const out = JSON.parse(proc.stdout.toString().trim());
+    expect(out.status).toBe(200);
+    expect(out.body).toBe(JSON.stringify({ n: "not-a-number" }));
+    expect(proc.stderr.toString()).toContain("Response schema violation");
+  });
 });
 
 // ─── coverage-gate audit (per-status regression) ─────────────────────────────

package/src/tests/openapi-route-headers.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Request headers declared on a route must reach the generated spec as real
+ * OpenAPI parameters — documenting them in prose leaves generated clients
+ * unable to send them.
+ */
+
+import { describe, expect, test } from "bun:test";
+import "../http/all-routes";
+import { generateOpenApiSpec } from "../http/openapi";
+
+type Parameter = {
+  name: string;
+  in: string;
+  required?: boolean;
+  description?: string;
+  schema?: { type?: string };
+};
+
+const spec = JSON.parse(generateOpenApiSpec({ version: "test" })) as {
+  paths: Record<string, Record<string, { parameters?: Parameter[] }>>;
+};
+
+function headerParams(path: string, method = "post"): Parameter[] {
+  return (spec.paths[path]?.[method]?.parameters ?? []).filter((p) => p.in === "header");
+}
+
+/** Every operation whose contract includes the runtime identity. */
+const RUNTIME_HEADER_OPERATIONS: Array<[string, string]> = [
+  ["/ping", "post"],
+  ["/close", "post"],
+  ["/api/poll", "get"],
+  ["/api/agents/{id}/credential-status", "put"],
+  ["/api/scripts/run", "post"],
+  ["/api/mcp-bridge", "post"],
+];
+
+describe("runtime identity header in OpenAPI", () => {
+  for (const [path, method] of RUNTIME_HEADER_OPERATIONS) {
+    test(`${method.toUpperCase()} ${path} declares X-Runtime-Instance-ID as a header parameter`, () => {
+      const header = headerParams(path, method).find((p) => p.name === "X-Runtime-Instance-ID");
+      expect(header).toBeDefined();
+      expect(header?.in).toBe("header");
+      expect(header?.schema?.type).toBe("string");
+    });
+
+    test(`${method.toUpperCase()} ${path} marks the header optional — the requirement is mode-dependent`, () => {
+      const header = headerParams(path, method).find((p) => p.name === "X-Runtime-Instance-ID");
+      expect(header?.required).toBe(false);
+    });
+
+    test(`${method.toUpperCase()} ${path} describes what the header identifies`, () => {
+      const header = headerParams(path, method).find((p) => p.name === "X-Runtime-Instance-ID");
+      expect(header?.description).toContain("runtime instance");
+      expect(header?.description).toContain("MULTI_RUNTIME_ENABLED");
+    });
+  }
+
+  test("routes that declare no headers emit none", () => {
+    // Representative routes across the surface, none of which opt in.
+    expect(headerParams("/api/agents")).toHaveLength(0);
+    expect(headerParams("/api/config", "put")).toHaveLength(0);
+    expect(headerParams("/api/tasks")).toHaveLength(0);
+  });
+
+  test("header support adds parameters to no other operation", () => {
+    const withHeaders: string[] = [];
+    for (const [path, methods] of Object.entries(spec.paths)) {
+      for (const [method, op] of Object.entries(methods)) {
+        if ((op.parameters ?? []).some((p) => p.in === "header")) {
+          withHeaders.push(`${method.toUpperCase()} ${path}`);
+        }
+      }
+    }
+    expect(withHeaders.sort()).toEqual([
+      "GET /api/poll",
+      "POST /api/mcp-bridge",
+      "POST /api/scripts/run",
+      "POST /close",
+      "POST /ping",
+      "PUT /api/agents/{id}/credential-status",
+    ]);
+  });
+});

package/src/tests/opencode-adapter.test.ts

@@ -1017,6 +1017,46 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
     expect(opts.config?.permission?.edit).toBe("allow");
   });
 
+  test("swarm MCP headers carry the per-boot runtime identity when set", async () => {
+    const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
+    process.env.SWARM_RUNTIME_INSTANCE_ID = "opencode-runtime-1";
+    try {
+      const events: OpencodeEvent[] = [
+        { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+      ];
+      await driveSession(events, testConfig({ taskId: "task-1" }));
+
+      const opts = lastCreateOpencodeConfig as {
+        config?: { mcp?: Record<string, { headers?: Record<string, string> }> };
+      };
+      expect(opts.config?.mcp?.swarm?.headers?.["X-Runtime-Instance-ID"]).toBe(
+        "opencode-runtime-1",
+      );
+    } finally {
+      if (prev === undefined) delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+      else process.env.SWARM_RUNTIME_INSTANCE_ID = prev;
+    }
+  });
+
+  test("swarm MCP headers omit the runtime identity when unset", async () => {
+    const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
+    delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+    try {
+      const events: OpencodeEvent[] = [
+        { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+      ];
+      await driveSession(events, testConfig({ taskId: "task-1" }));
+
+      const opts = lastCreateOpencodeConfig as {
+        config?: { mcp?: Record<string, { headers?: Record<string, string> }> };
+      };
+      expect(opts.config?.mcp?.swarm?.headers?.["X-Runtime-Instance-ID"]).toBeUndefined();
+    } finally {
+      if (prev === undefined) delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+      else process.env.SWARM_RUNTIME_INSTANCE_ID = prev;
+    }
+  });
+
   test("per-task agent file is written with system prompt", async () => {
     const cwd = `/tmp/opencode-test-agent-${Date.now()}`;
     await Bun.$`mkdir -p ${cwd}`.quiet();

package/src/tests/outbound-listener-rejection.test.ts

@@ -0,0 +1,138 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { initJiraOutboundSync, teardownJiraOutboundSync } from "../jira/outbound";
+import { initLinearOutboundSync, teardownLinearOutboundSync } from "../linear/outbound";
+import { workflowEventBus } from "../workflows/event-bus";
+
+/**
+ * `EventEmitter.emit()` invokes listeners synchronously and discards whatever
+ * they return, so wrapping the *emitting* side in `.catch()` never observes an
+ * async subscriber's rejection — it reaches the process-level
+ * `unhandledRejection` handler instead, with no subsystem context.
+ *
+ * These tests exercise the subscription boundary rather than EventEmitter
+ * itself. A `null` payload makes the handler's first destructuring statement
+ * throw, which rejects the returned promise from *outside* any internal
+ * `try`/`catch` — the same shape as a database failure in the tracker lookup
+ * that both subsystems perform before their first `try`.
+ */
+
+/** Let the rejection settle: one microtask drain plus one macrotask turn. */
+async function settle(): Promise<void> {
+  await Promise.resolve();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+describe("outbound event-bus listener rejection handling", () => {
+  let errorSpy: ReturnType<typeof spyOn<Console, "error">>;
+  let logSpy: ReturnType<typeof spyOn<Console, "log">>;
+  let unhandled: unknown[];
+  const onUnhandled = (reason: unknown) => unhandled.push(reason);
+
+  beforeEach(() => {
+    unhandled = [];
+    process.on("unhandledRejection", onUnhandled);
+    errorSpy = spyOn(console, "error").mockImplementation(() => {});
+    logSpy = spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    teardownJiraOutboundSync();
+    teardownLinearOutboundSync();
+    errorSpy.mockRestore();
+    logSpy.mockRestore();
+    process.off("unhandledRejection", onUnhandled);
+  });
+
+  /**
+   * Other suites in the same process may leave their own subscribers attached,
+   * and they log through the same `console.error`. Assert on the subsystem
+   * under test rather than on global log emptiness, so this file does not
+   * depend on which tests ran before it.
+   */
+  const messages = (prefix: string) =>
+    errorSpy.mock.calls.map((args) => String(args[0])).filter((m) => m.startsWith(prefix));
+
+  test("a rejecting Jira listener is reported by the subsystem, not left unhandled", async () => {
+    initJiraOutboundSync();
+
+    workflowEventBus.emit("task.completed", null);
+    await settle();
+
+    expect(messages("[Jira Outbound]")).toContain("[Jira Outbound] task.completed handler failed:");
+    expect(unhandled).toEqual([]);
+  });
+
+  test("a rejecting Linear listener is reported by the subsystem, not left unhandled", async () => {
+    initLinearOutboundSync();
+
+    workflowEventBus.emit("task.completed", null);
+    await settle();
+
+    expect(messages("[Linear Outbound]")).toContain(
+      "[Linear Outbound] task.completed handler failed:",
+    );
+    expect(unhandled).toEqual([]);
+  });
+
+  test("the reported error carries the reason as scrubbed text, not the raw object", async () => {
+    initJiraOutboundSync();
+
+    workflowEventBus.emit("task.failed", null);
+    await settle();
+
+    const call = errorSpy.mock.calls.find(
+      (args) => String(args[0]) === "[Jira Outbound] task.failed handler failed:",
+    );
+    expect(call).toBeDefined();
+    // Text, not the Error itself: a raw SDK error would serialise attached
+    // request/response fields that can hold credentials.
+    expect(typeof call?.[1]).toBe("string");
+    // The underlying reason survives; only the object wrapper is dropped.
+    expect(String(call?.[1])).toMatch(/null/);
+  });
+
+  test("every subscribed event is observed, not just one", async () => {
+    initJiraOutboundSync();
+
+    for (const event of ["task.created", "task.completed", "task.failed", "task.cancelled"]) {
+      workflowEventBus.emit(event, null);
+    }
+    await settle();
+
+    for (const event of ["task.created", "task.completed", "task.failed", "task.cancelled"]) {
+      expect(messages("[Jira Outbound]")).toContain(`[Jira Outbound] ${event} handler failed:`);
+    }
+    expect(unhandled).toEqual([]);
+  });
+
+  test("teardown removes the wrapper that was registered", async () => {
+    initJiraOutboundSync();
+    initLinearOutboundSync();
+    teardownJiraOutboundSync();
+    teardownLinearOutboundSync();
+    errorSpy.mockClear();
+
+    workflowEventBus.emit("task.completed", null);
+    await settle();
+
+    // If `off()` had been passed a different reference than `on()`, the
+    // listener would still be attached and would report here.
+    expect(messages("[Jira Outbound]")).toEqual([]);
+    expect(messages("[Linear Outbound]")).toEqual([]);
+    expect(unhandled).toEqual([]);
+  });
+
+  test("normally handled events still complete without being reported", async () => {
+    initJiraOutboundSync();
+    initLinearOutboundSync();
+
+    // No taskId — both subsystems return early, which is the ordinary
+    // no-op path for the vast majority of swarm tasks.
+    workflowEventBus.emit("task.completed", {});
+    await settle();
+
+    expect(messages("[Jira Outbound]")).toEqual([]);
+    expect(messages("[Linear Outbound]")).toEqual([]);
+    expect(unhandled).toEqual([]);
+  });
+});

package/src/tests/pi-mono-adapter.test.ts

@@ -171,6 +171,104 @@ describe("PiMonoAdapter.createSession — OPENROUTER_BASE_URL gateway", () => {
   });
 });
 
+// ─── MCP runtime identity (multi-runtime dispatch gate) ──────────────────────
+
+describe("PiMonoAdapter.createSession — MCP runtime identity header", () => {
+  let createAgentSessionSpy: ReturnType<typeof spyOn>;
+
+  afterEach(() => {
+    createAgentSessionSpy?.mockRestore();
+  });
+
+  function spyOnCreateAgentSession() {
+    createAgentSessionSpy = spyOn(piCodingAgent, "createAgentSession").mockImplementation((async (
+      _opts: Record<string, unknown>,
+    ) => {
+      return {
+        session: {
+          sessionId: "fake-session",
+          isStreaming: false,
+          model: undefined,
+          subscribe: () => () => {},
+          dispose: () => {},
+        },
+      };
+    }) as typeof piCodingAgent.createAgentSession);
+  }
+
+  function makeMcpConfig(apiUrl: string): ProviderSessionConfig {
+    return {
+      prompt: "hello",
+      systemPrompt: "",
+      model: "openrouter/google/gemini-3-flash-preview",
+      role: "worker",
+      agentId: "test-agent",
+      taskId: "test-task",
+      apiUrl,
+      apiKey: "test-key",
+      cwd: "/tmp",
+      logFile: `/tmp/pi-mcp-header-test-${Date.now()}-${Math.random().toString(36).slice(2)}.log`,
+    };
+  }
+
+  /** Stub swarm API: records the runtime header on every /mcp request. */
+  function serveStub(seen: Array<string | null>) {
+    return Bun.serve({
+      port: 0,
+      fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname === "/mcp") {
+          seen.push(req.headers.get("x-runtime-instance-id"));
+          return Response.json({
+            jsonrpc: "2.0",
+            id: 1,
+            result: { protocolVersion: "2025-03-26", capabilities: {}, tools: [] },
+          });
+        }
+        return Response.json({ servers: [] });
+      },
+    });
+  }
+
+  test("swarm MCP requests carry the per-boot X-Runtime-Instance-ID", async () => {
+    const seen: Array<string | null> = [];
+    const server = serveStub(seen);
+    const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
+    process.env.SWARM_RUNTIME_INSTANCE_ID = "pi-runtime-1";
+    try {
+      spyOnCreateAgentSession();
+      const adapter = new PiMonoAdapter();
+      await adapter.createSession(makeMcpConfig(`http://localhost:${server.port}`));
+      // initialize + initialized + tools/list all hit /mcp — every one must
+      // present the same per-boot identity.
+      expect(seen.length).toBeGreaterThan(0);
+      expect(new Set(seen)).toEqual(new Set(["pi-runtime-1"]));
+    } finally {
+      if (prev === undefined) delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+      else process.env.SWARM_RUNTIME_INSTANCE_ID = prev;
+      server.stop(true);
+    }
+  });
+
+  test("no per-boot identity in the environment → no runtime header", async () => {
+    const seen: Array<string | null> = [];
+    const server = serveStub(seen);
+    const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
+    delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+    try {
+      spyOnCreateAgentSession();
+      const adapter = new PiMonoAdapter();
+      await adapter.createSession(makeMcpConfig(`http://localhost:${server.port}`));
+      expect(seen.length).toBeGreaterThan(0);
+      expect(new Set(seen)).toEqual(new Set([null]));
+    } finally {
+      if (prev === undefined) delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+      else process.env.SWARM_RUNTIME_INSTANCE_ID = prev;
+      server.stop(true);
+    }
+  });
+});
+
 describe("AGENTS.md symlink management", () => {
   const tmpDir = `/tmp/pi-mono-test-${Date.now()}`;
 

package/src/tests/profile-sync-warning.test.ts

@@ -0,0 +1,277 @@
+import { describe, expect, test } from "bun:test";
+import {
+  contentSha256,
+  fetchProfileSyncRejectionBanner,
+  prependProfileSyncRejectionBanner,
+  renderProfileSyncRejectionBanner,
+  TOOLS_MD_PATH,
+  WORKSPACE_CLAUDE_MD_PATH,
+} from "../commands/profile-sync";
+import type { SwarmEvent } from "../types";
+
+const rejectionEvent: SwarmEvent = {
+  id: "00000000-0000-4000-8000-000000000001",
+  category: "system",
+  event: "system.profile_sync_rejected",
+  status: "error",
+  source: "api",
+  agentId: "agent-1",
+  createdAt: "2026-08-18T15:55:00.000Z",
+  data: {
+    field: "toolsMd",
+    diskSize: 84_574,
+    dbSize: 83_679,
+    budget: 20_000,
+    delta: 895,
+    dbHash: contentSha256("db tools"),
+    changeSource: "session_sync",
+  },
+};
+
+const reconciliationEvent: SwarmEvent = {
+  ...rejectionEvent,
+  id: "00000000-0000-4000-8000-000000000003",
+  event: "system.profile_sync_reconciled",
+  status: "ok",
+  createdAt: "2026-08-18T16:00:00.000Z",
+};
+
+describe("profile sync rejection session warning", () => {
+  test("carries field, disk size, DB size, budget, delta, and recovery path", async () => {
+    const banner = await renderProfileSyncRejectionBanner(rejectionEvent);
+
+    expect(banner).toContain("/workspace/TOOLS.md");
+    expect(banner).toContain("Disk size: 84574");
+    expect(banner).toContain("DB size: 83679");
+    expect(banner).toContain("budget: 20000");
+    expect(banner).toContain("delta: +895");
+    expect(banner).toContain(".pre-boot-<timestamp>.bak");
+    expect(banner.indexOf("live /workspace/TOOLS.md")).toBeLessThan(
+      banner.indexOf("/workspace/TOOLS.md.pre-boot-<timestamp>.bak"),
+    );
+    expect(banner).toContain(rejectionEvent.id);
+  });
+
+  test("queries the latest persisted event for the current agent", async () => {
+    const requests: Request[] = [];
+    const fetchImpl = (async (input: string | URL | Request, init?: RequestInit) => {
+      const request = new Request(input, init);
+      requests.push(request);
+      const field = new URL(request.url).searchParams.get("dataField");
+      const body = request.url.endsWith("/me")
+        ? { toolsMd: "db tools" }
+        : { events: field === "toolsMd" ? [rejectionEvent] : [] };
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as typeof fetch;
+
+    const result = await prependProfileSyncRejectionBanner(
+      "ORIGINAL TASK PROMPT",
+      {
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+        agentId: "agent-1",
+      },
+      fetchImpl,
+    );
+
+    expect(requests[0]?.url).toContain("event=system.profile_sync_rejected");
+    expect(requests[0]?.url).toContain("agentId=agent-1");
+    expect(requests[0]?.url).toContain("limit=1");
+    expect(requests[0]?.url).toContain("dataField=soulMd");
+    expect(requests[0]?.headers.get("X-Agent-ID")).toBe("agent-1");
+    expect(requests.at(-1)?.url).toBe("https://api.example.test/me");
+    expect(result.injected).toBeTrue();
+    expect(result.prompt).toContain("PERSISTED PROFILE SYNC REJECTION");
+    expect(result.prompt).toEndWith("ORIGINAL TASK PROMPT");
+  });
+
+  test("stops warning after the stored field changes", async () => {
+    const fetchImpl = (async (input: string | URL | Request) => {
+      const url = String(input);
+      const field = new URL(url).searchParams.get("dataField");
+      const body = url.endsWith("/me")
+        ? { toolsMd: "reconciled tools" }
+        : { events: field === "toolsMd" ? [rejectionEvent] : [] };
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as typeof fetch;
+
+    const banner = await fetchProfileSyncRejectionBanner(
+      {
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+        agentId: "agent-1",
+      },
+      fetchImpl,
+    );
+
+    expect(banner).toBe("");
+  });
+
+  test("stops warning after a successful no-op reconciliation", async () => {
+    const fetchImpl = (async (input: string | URL | Request) => {
+      const url = new URL(String(input));
+      const field = url.searchParams.get("dataField");
+      const event = url.searchParams.get("event");
+      const body = url.pathname.endsWith("/me")
+        ? { toolsMd: "db tools" }
+        : {
+            events:
+              field !== "toolsMd"
+                ? []
+                : event === "system.profile_sync_reconciled"
+                  ? [reconciliationEvent]
+                  : [rejectionEvent],
+          };
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as typeof fetch;
+
+    const banner = await fetchProfileSyncRejectionBanner(
+      {
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+        agentId: "agent-1",
+      },
+      fetchImpl,
+    );
+
+    expect(banner).toBe("");
+  });
+
+  test("keeps warning when the latest reconciliation predates the rejection", async () => {
+    const olderReconciliation = {
+      ...reconciliationEvent,
+      createdAt: "2026-08-18T15:50:00.000Z",
+    };
+    const fetchImpl = (async (input: string | URL | Request) => {
+      const url = new URL(String(input));
+      const field = url.searchParams.get("dataField");
+      const event = url.searchParams.get("event");
+      const body = url.pathname.endsWith("/me")
+        ? { toolsMd: "db tools" }
+        : {
+            events:
+              field !== "toolsMd"
+                ? []
+                : event === "system.profile_sync_reconciled"
+                  ? [olderReconciliation]
+                  : [rejectionEvent],
+          };
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as typeof fetch;
+
+    const banner = await fetchProfileSyncRejectionBanner(
+      {
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+        agentId: "agent-1",
+      },
+      fetchImpl,
+    );
+
+    expect(banner).toContain("PERSISTED PROFILE SYNC REJECTION");
+  });
+
+  test("clears a warning only when boot restored the local file to the DB value", async () => {
+    const fetchImpl = (async (input: string | URL | Request) => {
+      const url = new URL(String(input));
+      const field = url.searchParams.get("dataField");
+      const event = url.searchParams.get("event");
+      const body = url.pathname.endsWith("/me")
+        ? { toolsMd: "db tools" }
+        : {
+            events:
+              field === "toolsMd" && event === "system.profile_sync_rejected"
+                ? [rejectionEvent]
+                : [],
+          };
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as typeof fetch;
+    const config = {
+      apiUrl: "https://api.example.test",
+      apiKey: "secret-key",
+      agentId: "agent-1",
+      claudeMdPath: WORKSPACE_CLAUDE_MD_PATH,
+    };
+
+    const restored = await fetchProfileSyncRejectionBanner(config, fetchImpl, async (path) =>
+      path === TOOLS_MD_PATH ? "db tools" : undefined,
+    );
+    const stillDiverged = await fetchProfileSyncRejectionBanner(config, fetchImpl, async (path) =>
+      path === TOOLS_MD_PATH ? "rejected tools" : undefined,
+    );
+
+    expect(restored).toBe("");
+    expect(stillDiverged).toContain("PERSISTED PROFILE SYNC REJECTION");
+  });
+
+  test("surfaces the latest unresolved rejection for every affected field", async () => {
+    const claudeEvent: SwarmEvent = {
+      ...rejectionEvent,
+      id: "00000000-0000-4000-8000-000000000002",
+      data: {
+        ...rejectionEvent.data,
+        field: "claudeMd",
+        diskSize: 99_617,
+        dbSize: 99_602,
+        delta: 15,
+        dbHash: contentSha256("db claude"),
+      },
+    };
+    const fetchImpl = (async (input: string | URL | Request) => {
+      const url = String(input);
+      const field = new URL(url).searchParams.get("dataField");
+      const body = url.endsWith("/me")
+        ? { toolsMd: "db tools", claudeMd: "db claude" }
+        : {
+            events:
+              field === "claudeMd" ? [claudeEvent] : field === "toolsMd" ? [rejectionEvent] : [],
+          };
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as typeof fetch;
+
+    const banner = await fetchProfileSyncRejectionBanner(
+      {
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+        agentId: "agent-1",
+      },
+      fetchImpl,
+    );
+
+    expect(banner).toContain("/workspace/CLAUDE.md");
+    expect(banner).toContain("~/.claude/CLAUDE.md");
+    expect(banner).toContain("is not archived by that boot step");
+    expect(banner).toContain("/workspace/TOOLS.md");
+  });
+
+  test("fails open when the audit event cannot be fetched", async () => {
+    const banner = await fetchProfileSyncRejectionBanner(
+      {
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+        agentId: "agent-1",
+      },
+      (async () => new Response("unavailable", { status: 503 })) as typeof fetch,
+    );
+
+    expect(banner).toBe("");
+  });
+});