@desplega.ai/agent-swarm 1.131.1 → 1.134.0

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("");
+  });
+});

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

@@ -1,11 +1,14 @@
 import { describe, expect, spyOn, test } from "bun:test";
 import {
   buildIdentityPayload,
+  buildIndependentIdentityPayloads,
   CLAUDE_MD_PATH,
   collectProfilePayloads,
   contentSha256,
   extractSetupScriptContent,
   type FileReader,
+  findProfileDivergences,
+  HEARTBEAT_MD_PATH,
   IDENTITY_BASELINES_PATH,
   IDENTITY_MD_PATH,
   type IdentityBaselines,
@@ -17,7 +20,9 @@ import {
   TOOLS_MD_PATH,
   WORKSPACE_CLAUDE_MD_PATH,
 } from "../commands/profile-sync";
+import { profileSyncAuditExitCode, runProfileSyncAudit } from "../commands/profile-sync-audit";
 import { MAX_PROFILE_FILE_LENGTH } from "../utils/constants";
+import { IDENTITY_FIELD_BUDGETS } from "../utils/identity-field-budget";
 
 const MARKER_START = "# === Agent-managed setup (from DB) ===";
 const MARKER_END = "# === End agent-managed setup ===";
@@ -25,6 +30,182 @@ const MARKER_END = "# === End agent-managed setup ===";
 // A SOUL/IDENTITY body long enough to clear the 500-char min-length guard.
 const LONG = "x".repeat(600);
 
+describe("profile divergence audit", () => {
+  test("compares all four budgeted fields plus ungated heartbeatMd", () => {
+    const divergences = findProfileDivergences(
+      {
+        soulMd: "disk soul",
+        identityMd: "disk identity",
+        claudeMd: "disk claude",
+        toolsMd: "disk tools",
+        heartbeatMd: "disk heartbeat",
+      },
+      {
+        soulMd: "db soul",
+        identityMd: "db identity",
+        claudeMd: "db claude",
+        toolsMd: "db tools",
+        heartbeatMd: "db heartbeat",
+      },
+    );
+
+    expect(divergences.map((entry) => entry.field)).toEqual([
+      "soulMd",
+      "identityMd",
+      "claudeMd",
+      "toolsMd",
+      "heartbeatMd",
+    ]);
+    expect(divergences[0]?.budget).toBe(IDENTITY_FIELD_BUDGETS.soulMd);
+    expect(divergences[2]?.budget).toBe(IDENTITY_FIELD_BUDGETS.claudeMd);
+    expect(divergences[4]?.budget).toBeNull();
+    expect(divergences[4]?.diskSize).toBe("disk heartbeat".length);
+    expect(divergences[4]?.dbSize).toBe("db heartbeat".length);
+  });
+
+  test("fetches the DB profile and reads the canonical local paths", async () => {
+    const local = {
+      [SOUL_MD_PATH]: "same soul",
+      [IDENTITY_MD_PATH]: "disk identity",
+      [WORKSPACE_CLAUDE_MD_PATH]: "same claude",
+      [TOOLS_MD_PATH]: "same tools",
+      [HEARTBEAT_MD_PATH]: "disk heartbeat",
+    };
+    const readFile: FileReader = async (path) => local[path as keyof typeof local];
+    let request: Request | null = null;
+    const fetchImpl = (async (input: string | URL | Request, init?: RequestInit) => {
+      request = new Request(input, init);
+      return new Response(
+        JSON.stringify({
+          soulMd: "same soul",
+          identityMd: "db identity",
+          claudeMd: "same claude",
+          toolsMd: "same tools",
+          heartbeatMd: "db heartbeat",
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }) as typeof fetch;
+
+    const result = await runProfileSyncAudit(
+      {
+        agentId: "agent-1",
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+        claudeMdPath: WORKSPACE_CLAUDE_MD_PATH,
+      },
+      { fetchImpl, readFile },
+    );
+
+    expect(request?.url).toBe("https://api.example.test/me");
+    expect(request?.headers.get("X-Agent-ID")).toBe("agent-1");
+    expect(result.divergences.map((entry) => entry.field)).toEqual(["identityMd", "heartbeatMd"]);
+  });
+
+  test("uses the registered effective provider to select the Claude profile path", async () => {
+    const readPaths: string[] = [];
+    const readFile: FileReader = async (path) => {
+      readPaths.push(path);
+      return "same";
+    };
+    const fetchImpl = (async () =>
+      new Response(
+        JSON.stringify({
+          harnessProvider: "codex",
+          soulMd: "same",
+          identityMd: "same",
+          claudeMd: "same",
+          toolsMd: "same",
+          heartbeatMd: "same",
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      )) as typeof fetch;
+
+    const result = await runProfileSyncAudit(
+      {
+        agentId: "agent-codex",
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+      },
+      { fetchImpl, readFile },
+    );
+
+    expect(result.divergences).toEqual([]);
+    expect(readPaths).toContain(WORKSPACE_CLAUDE_MD_PATH);
+    expect(readPaths).not.toContain(CLAUDE_MD_PATH);
+  });
+
+  test("refuses to guess the audit path when no effective provider is registered", async () => {
+    const fetchImpl = (async () =>
+      new Response(JSON.stringify({}), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      })) as typeof fetch;
+
+    expect(
+      runProfileSyncAudit(
+        {
+          agentId: "agent-unregistered",
+          apiUrl: "https://api.example.test",
+          apiKey: "secret-key",
+        },
+        { fetchImpl, readFile: async () => undefined },
+      ),
+    ).rejects.toThrow("registered harness provider");
+  });
+
+  test("treats profile fields absent on disk and empty in the DB as equal", async () => {
+    const readFile: FileReader = async () => undefined;
+    const fetchImpl = (async () =>
+      new Response(JSON.stringify({ soulMd: "" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      })) as typeof fetch;
+
+    const result = await runProfileSyncAudit(
+      {
+        agentId: "agent-unset",
+        apiUrl: "https://api.example.test",
+        apiKey: "secret-key",
+        claudeMdPath: WORKSPACE_CLAUDE_MD_PATH,
+      },
+      { fetchImpl, readFile },
+    );
+
+    expect(result.divergences).toEqual([]);
+    expect(profileSyncAuditExitCode(result.divergences)).toBe(0);
+  });
+
+  test("reports a missing local file when the DB value is non-empty", () => {
+    const divergences = findProfileDivergences(
+      {
+        soulMd: undefined,
+        identityMd: "same identity",
+        claudeMd: "same claude",
+        toolsMd: "same tools",
+        heartbeatMd: "same heartbeat",
+      },
+      {
+        soulMd: "stored soul",
+        identityMd: "same identity",
+        claudeMd: "same claude",
+        toolsMd: "same tools",
+        heartbeatMd: "same heartbeat",
+      },
+    );
+
+    expect(divergences).toHaveLength(1);
+    expect(divergences[0]).toMatchObject({
+      field: "soulMd",
+      diskMissing: true,
+      diskSize: null,
+      diskHash: null,
+      dbSize: "stored soul".length,
+      delta: null,
+    });
+  });
+});
+
 describe("extractSetupScriptContent (marker extraction)", () => {
   test("extracts ONLY the content between the agent-managed markers", () => {
     const raw = [
@@ -97,6 +278,19 @@ describe("buildIdentityPayload (min-length guard)", () => {
     expect(payload.heartbeatMd).toBe("");
   });
 
+  test("forwards oversized gated identity fields so the server ratchet can decide", () => {
+    const oversized = "x".repeat(MAX_PROFILE_FILE_LENGTH + 1);
+    const payload = buildIdentityPayload({
+      soulMd: oversized,
+      identityMd: oversized,
+      toolsMd: oversized,
+    });
+
+    expect(payload.soulMd).toBe(oversized);
+    expect(payload.identityMd).toBe(oversized);
+    expect(payload.toolsMd).toBe(oversized);
+  });
+
   test("logs the agent, field, actual length, and cap when a file is too large", () => {
     const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
     try {
@@ -142,7 +336,13 @@ describe("collectProfilePayloads (field gate)", () => {
       "session_sync",
       files,
     );
-    expect(all.map((p) => p.label).sort()).toEqual(["claude", "identity", "setup"]);
+    expect(all.map((p) => p.label).sort()).toEqual([
+      "claude",
+      "identity.identityMd",
+      "identity.soulMd",
+      "identity.toolsMd",
+      "setup",
+    ]);
   });
 
   test("a missing file yields no payload for that group (no empty POST)", async () => {
@@ -413,11 +613,13 @@ describe("collectProfilePayloads (baseline integration)", () => {
     });
 
     const payloads = await collectProfilePayloads(["identity"], "self_edit", files);
-    expect(payloads).toHaveLength(1);
-    // self_edit should include ALL files regardless of baselines
-    expect(payloads[0]?.body.soulMd).toBe(identityContent);
-    expect(payloads[0]?.body.identityMd).toBe(identityContent);
-    expect(payloads[0]?.body.toolsMd).toBe("tools");
+    expect(payloads).toHaveLength(3);
+    // self_edit should include ALL files regardless of baselines, independently.
+    expect(payloads.map((payload) => payload.body)).toEqual([
+      { soulMd: identityContent, changeSource: "self_edit" },
+      { identityMd: identityContent, changeSource: "self_edit" },
+      { toolsMd: "tools", changeSource: "self_edit" },
+    ]);
   });
 
   test("session_sync skips unchanged CLAUDE.md when baseline matches", async () => {
@@ -482,3 +684,27 @@ describe("collectProfilePayloads (baseline integration)", () => {
     expect(payloads).toEqual([]);
   });
 });
+
+describe("buildIndependentIdentityPayloads", () => {
+  test("splits fields so one rejected write cannot discard valid siblings", () => {
+    expect(
+      buildIndependentIdentityPayloads(
+        { soulMd: "rejected growth", toolsMd: "valid edit", heartbeatMd: "ungated edit" },
+        "session_sync",
+      ),
+    ).toEqual([
+      {
+        label: "identity.soulMd",
+        body: { soulMd: "rejected growth", changeSource: "session_sync" },
+      },
+      {
+        label: "identity.toolsMd",
+        body: { toolsMd: "valid edit", changeSource: "session_sync" },
+      },
+      {
+        label: "identity.heartbeatMd",
+        body: { heartbeatMd: "ungated edit", changeSource: "session_sync" },
+      },
+    ]);
+  });
+});