@desplega.ai/agent-swarm 1.131.0 → 1.133.1

package/src/tests/http-api-integration.test.ts

@@ -11,6 +11,7 @@ import type { Subprocess } from "bun";
 import { Webhook } from "svix";
 import { slackContextKey } from "../tasks/context-key";
 import { MAX_PROFILE_FILE_LENGTH } from "../utils/constants";
+import { SOUL_MD_MAX_CHARS } from "../utils/identity-field-budget";
 
 const TEST_PORT = Number(
   process.env.HTTP_API_INTEGRATION_TEST_PORT ?? 30000 + Math.floor(Math.random() * 20000),
@@ -315,6 +316,86 @@ describe("Agents", () => {
     expect(rejected.status).toBe(400);
   });
 
+  test("PUT /api/agents/:id/profile — persists structured filesystem sync rejections", async () => {
+    const current = "s".repeat(SOUL_MD_MAX_CHARS);
+    const accepted = await put(`/api/agents/${ids.workerAgent}/profile`, {
+      body: { soulMd: current, changeSource: "session_sync" },
+      agentId: ids.workerAgent,
+    });
+    expect(accepted.status).toBe(200);
+
+    const rejected = await put(`/api/agents/${ids.workerAgent}/profile`, {
+      body: { soulMd: `${current}x`, changeSource: "session_sync" },
+      agentId: ids.workerAgent,
+    });
+    expect(rejected.status).toBe(400);
+    expect(rejected.body.profileSyncRejection).toMatchObject({
+      field: "soulMd",
+      diskSize: SOUL_MD_MAX_CHARS + 1,
+      dbSize: SOUL_MD_MAX_CHARS,
+      budget: SOUL_MD_MAX_CHARS,
+      delta: 1,
+    });
+
+    const query = new URLSearchParams({
+      event: "system.profile_sync_rejected",
+      agentId: ids.workerAgent,
+      dataField: "soulMd",
+      limit: "1",
+    });
+    const events = await get(`/api/events?${query}`, { agentId: ids.workerAgent });
+    expect(events.status).toBe(200);
+    expect(events.body.events).toHaveLength(1);
+    expect(events.body.events[0]).toMatchObject({
+      category: "system",
+      event: "system.profile_sync_rejected",
+      status: "error",
+      source: "api",
+      agentId: ids.workerAgent,
+      data: {
+        field: "soulMd",
+        diskSize: SOUL_MD_MAX_CHARS + 1,
+        dbSize: SOUL_MD_MAX_CHARS,
+        budget: SOUL_MD_MAX_CHARS,
+        delta: 1,
+        changeSource: "session_sync",
+      },
+    });
+
+    const reconciled = await put(`/api/agents/${ids.workerAgent}/profile`, {
+      body: { soulMd: current, changeSource: "session_sync" },
+      agentId: ids.workerAgent,
+    });
+    expect(reconciled.status).toBe(200);
+    const reconciliationEvents = await get(
+      `/api/events?${new URLSearchParams({
+        event: "system.profile_sync_reconciled",
+        agentId: ids.workerAgent,
+        dataField: "soulMd",
+        limit: "1",
+      })}`,
+      { agentId: ids.workerAgent },
+    );
+    expect(reconciliationEvents.status).toBe(200);
+    expect(reconciliationEvents.body.events[0]).toMatchObject({
+      event: "system.profile_sync_reconciled",
+      status: "ok",
+      data: { field: "soulMd", changeSource: "session_sync" },
+    });
+
+    const unrelated = await get(
+      `/api/events?${new URLSearchParams({
+        event: "system.profile_sync_rejected",
+        agentId: ids.workerAgent,
+        dataField: "toolsMd",
+        limit: "1",
+      })}`,
+      { agentId: ids.workerAgent },
+    );
+    expect(unrelated.status).toBe(200);
+    expect(unrelated.body.events).toHaveLength(0);
+  });
+
   test("PUT /api/agents/:id/profile — non-existent returns 404", async () => {
     const { status } = await put(`/api/agents/${randomUUID()}/profile`, {
       body: { role: "ghost" },

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

@@ -20,7 +20,20 @@ import {
   type Server,
   type ServerResponse,
 } from "node:http";
-import { closeDb, createUser, getBudget, getDb, initDb, upsertKv } from "../be/db";
+import {
+  closeDb,
+  createScheduledTask,
+  createUser,
+  createWorkflow,
+  createWorkflowRun,
+  getBudget,
+  getDb,
+  getScheduledTaskById,
+  getWorkflowRun,
+  initDb,
+  updateWorkflowRun,
+  upsertKv,
+} from "../be/db";
 import { fingerprintApiKey, linkIdentity } from "../be/users";
 import { handleCore } from "../http/core";
 import { handleUsers } from "../http/users";
@@ -91,6 +104,10 @@ beforeEach(() => {
   db.run("DELETE FROM user_identity_events");
   db.run("DELETE FROM user_external_ids");
   db.run("DELETE FROM user_tokens");
+  db.run("DELETE FROM workflow_run_steps");
+  db.run("DELETE FROM workflow_runs");
+  db.run("DELETE FROM workflows");
+  db.run("DELETE FROM scheduled_tasks");
   db.run("DELETE FROM users");
   db.run("DELETE FROM budgets");
   db.run("DELETE FROM kv_entries");
@@ -325,6 +342,56 @@ describe("PATCH /api/users/:id", () => {
     expect(fields).toContain("name");
     expect(fields).not.toContain("role");
   });
+
+  test("comms merges into metadata.comms and preserves sibling metadata keys", async () => {
+    const u = createUser({ name: "CommsMerge", metadata: { customerId: "abc123" } });
+
+    const r = await authedFetch(`/api/users/${u.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        comms: { tone: "casual", verbosity: "short" },
+      }),
+    });
+    expect(r.status).toBe(200);
+    const { user } = (await r.json()) as { user: { metadata: Record<string, unknown> | null } };
+    expect(user.metadata).toEqual({
+      customerId: "abc123",
+      comms: { tone: "casual", verbosity: "short" },
+    });
+  });
+
+  test("comms: null removes only the comms key", async () => {
+    const u = createUser({
+      name: "CommsRemove",
+      metadata: { customerId: "abc123", comms: { tone: "formal" } },
+    });
+
+    const r = await authedFetch(`/api/users/${u.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ comms: null }),
+    });
+    expect(r.status).toBe(200);
+    const { user } = (await r.json()) as { user: { metadata: Record<string, unknown> | null } };
+    expect(user.metadata).toEqual({ customerId: "abc123" });
+  });
+
+  test("comms combined with metadata applies metadata first then comms", async () => {
+    const u = createUser({ name: "CommsWithMetadata", metadata: { customerId: "abc123" } });
+
+    const r = await authedFetch(`/api/users/${u.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        metadata: { region: "eu" },
+        comms: { tone: "formal" },
+      }),
+    });
+    expect(r.status).toBe(200);
+    const { user } = (await r.json()) as { user: { metadata: Record<string, unknown> | null } };
+    expect(user.metadata).toEqual({
+      region: "eu",
+      comms: { tone: "formal" },
+    });
+  });
 });
 
 describe("identity link/unlink", () => {
@@ -620,6 +687,24 @@ describe("POST /api/users/:id/merge", () => {
     const actor = { kind: "operator" as const, id: OPERATOR_FP };
     linkIdentity(source.id, "slack", "U_SRC", actor);
     linkIdentity(source.id, "github", "src-gh", actor);
+    const workflow = createWorkflow({
+      name: `merge-user-workflow-${crypto.randomUUID()}`,
+      definition: { nodes: [] },
+    });
+    const run = createWorkflowRun({
+      id: crypto.randomUUID(),
+      workflowId: workflow.id,
+      createdBy: source.id,
+    });
+    updateWorkflowRun(run.id, {
+      context: { swarm: { requestedByUserId: source.id }, retained: "value" },
+    });
+    const schedule = createScheduledTask({
+      name: `merge-user-schedule-${crypto.randomUUID()}`,
+      intervalMs: 60_000,
+      taskTemplate: "Run merged schedule",
+      createdBy: source.id,
+    });
 
     const r = await authedFetch(`/api/users/${target.id}/merge`, {
       method: "POST",
@@ -647,6 +732,13 @@ describe("POST /api/users/:id/merge", () => {
     // Source user is gone.
     const sourceR = await authedFetch(`/api/users/${source.id}`);
     expect(sourceR.status).toBe(404);
+    expect(getWorkflowRun(run.id)?.createdBy).toBe(target.id);
+    expect(getWorkflowRun(run.id)?.context).toEqual({
+      swarm: { requestedByUserId: target.id },
+      retained: "value",
+    });
+    expect(getScheduledTaskById(schedule.id)?.createdBy).toBe(target.id);
+    expect(getScheduledTaskById(schedule.id)?.updatedBy).toBe(target.id);
   });
 
   test("manual_merge event payload carries the source user's id/name", async () => {
@@ -675,6 +767,79 @@ describe("POST /api/users/:id/merge", () => {
     expect(mergeEvent!.after?.source?.email).toBe("ms@x.com");
   });
 
+  test("rolls back identity moves when deletion fails", async () => {
+    const target = createUser({ name: "RollbackTarget", email: "rollback-target@x.com" });
+    const source = createUser({ name: "RollbackSource", email: "rollback-source@x.com" });
+    const workflow = createWorkflow({
+      name: `rollback-attribution-${crypto.randomUUID()}`,
+      definition: { nodes: [] },
+    });
+    const run = createWorkflowRun({
+      id: crypto.randomUUID(),
+      workflowId: workflow.id,
+      createdBy: source.id,
+    });
+    updateWorkflowRun(run.id, {
+      context: { swarm: { requestedByUserId: source.id }, retained: "rollback" },
+    });
+    const schedule = createScheduledTask({
+      name: `rollback-user-schedule-${crypto.randomUUID()}`,
+      intervalMs: 60_000,
+      taskTemplate: "Retain rollback schedule",
+      createdBy: source.id,
+    });
+    linkIdentity(source.id, "slack", "U_MERGE_ROLLBACK", {
+      kind: "operator",
+      id: OPERATOR_FP,
+    });
+    getDb().run(`CREATE TEMP TRIGGER fail_merge_source_delete
+      BEFORE DELETE ON users WHEN OLD.id = '${source.id}'
+      BEGIN SELECT RAISE(ABORT, 'forced merge failure'); END`);
+
+    try {
+      const response = await authedFetch(`/api/users/${target.id}/merge`, {
+        method: "POST",
+        body: JSON.stringify({ sourceUserId: source.id }),
+      });
+      expect(response.status).toBe(500);
+
+      const identity = getDb()
+        .prepare<{ userId: string }, [string, string]>(
+          "SELECT userId FROM user_external_ids WHERE kind = ? AND externalId = ?",
+        )
+        .get("slack", "U_MERGE_ROLLBACK");
+      expect(identity?.userId).toBe(source.id);
+      expect(
+        getDb()
+          .prepare<{ count: number }, [string]>("SELECT COUNT(*) AS count FROM users WHERE id = ?")
+          .get(source.id)?.count,
+      ).toBe(1);
+      expect(
+        getDb()
+          .prepare<{ emailAliases: string }, [string]>(
+            "SELECT emailAliases FROM users WHERE id = ?",
+          )
+          .get(target.id)?.emailAliases,
+      ).toBe("[]");
+      expect(
+        getDb()
+          .prepare<{ count: number }, [string]>(
+            "SELECT COUNT(*) AS count FROM user_identity_events WHERE userId = ?",
+          )
+          .get(target.id)?.count,
+      ).toBe(0);
+      expect(getWorkflowRun(run.id)?.createdBy).toBe(source.id);
+      expect(getWorkflowRun(run.id)?.context).toEqual({
+        swarm: { requestedByUserId: source.id },
+        retained: "rollback",
+      });
+      expect(getScheduledTaskById(schedule.id)?.createdBy).toBe(source.id);
+      expect(getScheduledTaskById(schedule.id)?.updatedBy).toBe(source.id);
+    } finally {
+      getDb().run("DROP TRIGGER fail_merge_source_delete");
+    }
+  });
+
   test("400 when target == source", async () => {
     const u = createUser({ name: "Self" });
     const r = await authedFetch(`/api/users/${u.id}/merge`, {

package/src/tests/identity-field-budget.test.ts

@@ -0,0 +1,176 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { closeDb, createAgent, getAgentById, getDb, initDb, updateAgentProfile } from "../be/db";
+import { postHookProfileUpdate } from "../hooks/hook";
+import { BOOTSTRAP_MAX_CHARS } from "../prompts/base-prompt";
+import {
+  checkIdentityFieldBudget,
+  IDENTITY_FIELD_BUDGETS,
+  IDENTITY_MD_MAX_CHARS,
+  IdentityFieldBudgetError,
+  SOUL_MD_MAX_CHARS,
+} from "../utils/identity-field-budget";
+
+const TEST_DB_PATH = "./test-identity-field-budget.sqlite";
+
+describe("checkIdentityFieldBudget", () => {
+  test("exports the session-injection budgets from one policy module", () => {
+    expect(SOUL_MD_MAX_CHARS).toBe(10_000);
+    expect(IDENTITY_MD_MAX_CHARS).toBe(10_000);
+    expect(IDENTITY_FIELD_BUDGETS.claudeMd).toBe(BOOTSTRAP_MAX_CHARS);
+    expect(IDENTITY_FIELD_BUDGETS.toolsMd).toBe(BOOTSTRAP_MAX_CHARS);
+  });
+
+  test("accepts writes at or below budget, including growth", () => {
+    expect(
+      checkIdentityFieldBudget({
+        field: "soulMd",
+        currentValue: "x",
+        nextValue: "x".repeat(SOUL_MD_MAX_CHARS),
+      }),
+    ).toEqual({ ok: true });
+  });
+
+  test("accepts a shrinking write while the result remains over budget", () => {
+    expect(
+      checkIdentityFieldBudget({
+        field: "identityMd",
+        currentValue: "x".repeat(12_000),
+        nextValue: "x".repeat(11_999),
+      }),
+    ).toEqual({ ok: true });
+  });
+
+  test("rejects growth and accepts equal-length rewrites while over budget", () => {
+    const growing = checkIdentityFieldBudget({
+      field: "claudeMd",
+      currentValue: "x".repeat(BOOTSTRAP_MAX_CHARS + 1),
+      nextValue: "x".repeat(BOOTSTRAP_MAX_CHARS + 2),
+    });
+    const equal = checkIdentityFieldBudget({
+      field: "toolsMd",
+      currentValue: "x".repeat(BOOTSTRAP_MAX_CHARS + 1),
+      nextValue: "y".repeat(BOOTSTRAP_MAX_CHARS + 1),
+    });
+
+    expect(growing.ok).toBeFalse();
+    expect(equal).toEqual({ ok: true });
+    if (growing.ok) throw new Error("Expected budget rejection");
+    expect(growing.reason).toContain("claudeMd");
+    expect(growing.reason).toContain("current size 20001");
+    expect(growing.reason).toContain("budget 20000");
+    expect(growing.reason).toContain("delta +1");
+    expect(growing.reason).toBe(
+      "Update rejected for claudeMd: current size 20001 characters, budget 20000 characters, delta +1 characters." +
+        " The tail past the 20000-character cap is dropped from the base prompt and only reaches harnesses with a native CLAUDE.md loader." +
+        " Move durable content into memories and keep pointers to it in this field.",
+    );
+
+    const toolsGrowth = checkIdentityFieldBudget({
+      field: "toolsMd",
+      currentValue: "x".repeat(BOOTSTRAP_MAX_CHARS + 1),
+      nextValue: "x".repeat(BOOTSTRAP_MAX_CHARS + 2),
+    });
+    if (toolsGrowth.ok) throw new Error("Expected toolsMd budget rejection");
+    expect(toolsGrowth.reason).toBe(
+      "Update rejected for toolsMd: current size 20001 characters, budget 20000 characters, delta +1 characters." +
+        " Content past the 20000-character cap is already silently dropped at read time, so shrinking that tail loses nothing sessions currently receive." +
+        " Move durable content into memories and keep pointers to it in this field.",
+    );
+  });
+});
+
+describe("updateAgentProfile identity budget enforcement", () => {
+  const agentId = "identity-budget-agent";
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      await Bun.file(TEST_DB_PATH + suffix)
+        .delete()
+        .catch(() => {});
+    }
+    initDb(TEST_DB_PATH);
+    createAgent({ id: agentId, name: "Identity Budget Agent", isLead: false, status: "idle" });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      await Bun.file(TEST_DB_PATH + suffix)
+        .delete()
+        .catch(() => {});
+    }
+  });
+
+  test("preserves in-budget behavior and leaves heartbeatMd ungated", () => {
+    const heartbeat = "h".repeat(25_000);
+    const result = updateAgentProfile(agentId, {
+      soulMd: "s".repeat(SOUL_MD_MAX_CHARS),
+      heartbeatMd: heartbeat,
+    });
+
+    expect(result?.soulMd).toHaveLength(SOUL_MD_MAX_CHARS);
+    expect(result?.heartbeatMd).toBe(heartbeat);
+  });
+
+  test("allows an existing oversized value to shrink or change at equal length but rejects growth", () => {
+    const current = "c".repeat(BOOTSTRAP_MAX_CHARS + 10);
+    getDb().prepare("UPDATE agents SET claudeMd = ? WHERE id = ?").run(current, agentId);
+
+    const shrunk = "s".repeat(BOOTSTRAP_MAX_CHARS + 9);
+    expect(updateAgentProfile(agentId, { claudeMd: shrunk })?.claudeMd).toBe(shrunk);
+
+    const equalLength = "e".repeat(shrunk.length);
+    expect(updateAgentProfile(agentId, { claudeMd: equalLength })?.claudeMd).toBe(equalLength);
+    expect(() => updateAgentProfile(agentId, { claudeMd: `${equalLength}g` })).toThrow(
+      IdentityFieldBudgetError,
+    );
+    expect(getAgentById(agentId)?.claudeMd).toBe(equalLength);
+  });
+});
+
+describe("Stop-hook profile sync visibility", () => {
+  test("logs a rejected response with the server's budget reason", async () => {
+    const reason =
+      "Update rejected for toolsMd: current size 20001 characters, budget 20000 characters, delta +1 characters.";
+    const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+    try {
+      await postHookProfileUpdate({
+        url: "https://api.example.test/api/agents/agent-1/profile",
+        headers: { Authorization: "Bearer secret", "X-Agent-ID": "agent-1" },
+        body: { toolsMd: "next", changeSource: "session_sync" },
+        label: "identity",
+        fetchImpl: (async () =>
+          new Response(JSON.stringify({ error: reason }), { status: 400 })) as typeof fetch,
+      });
+
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      const logged = String(errorSpy.mock.calls[0]?.[0]);
+      expect(logged).toContain("identity profile sync failed: HTTP 400");
+      expect(logged).toContain(reason);
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  test("logs thrown sync errors without failing shutdown", async () => {
+    const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+    try {
+      await expect(
+        postHookProfileUpdate({
+          url: "https://api.example.test/api/agents/agent-1/profile",
+          headers: {},
+          body: { claudeMd: "next" },
+          label: "claudeMd",
+          fetchImpl: (async () => {
+            throw new Error("network unavailable");
+          }) as typeof fetch,
+        }),
+      ).resolves.toBeUndefined();
+      expect(String(errorSpy.mock.calls[0]?.[0])).toContain(
+        "claudeMd profile sync errored: network unavailable",
+      );
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+});

package/src/tests/mcp-tools-user.test.ts

@@ -436,4 +436,38 @@ describe("manage-user MCP tool (identities array)", () => {
     const idents = getUserIdentities(userId);
     expect(idents).toHaveLength(0);
   });
+
+  test("update with comms merges into metadata.comms and preserves sibling metadata keys", async () => {
+    const created = createUser({ name: "Comms Merge", metadata: { customerId: "abc123" } });
+
+    const result = await callTool(server, "manage-user", {
+      action: "update",
+      userId: created.id,
+      comms: { tone: "casual", verbosity: "short" },
+    });
+
+    expect(result.isError).toBe(false);
+    const user = structuredOf(result).user as { metadata: Record<string, unknown> | null };
+    expect(user.metadata).toEqual({
+      customerId: "abc123",
+      comms: { tone: "casual", verbosity: "short" },
+    });
+  });
+
+  test("update with comms: null removes only the comms key", async () => {
+    const created = createUser({
+      name: "Comms Remove",
+      metadata: { customerId: "abc123", comms: { tone: "formal" } },
+    });
+
+    const result = await callTool(server, "manage-user", {
+      action: "update",
+      userId: created.id,
+      comms: null,
+    });
+
+    expect(result.isError).toBe(false);
+    const user = structuredOf(result).user as { metadata: Record<string, unknown> | null };
+    expect(user.metadata).toEqual({ customerId: "abc123" });
+  });
 });

package/src/tests/mcp-user-route.test.ts

@@ -362,6 +362,23 @@ describe("/mcp-user auth and tool surface", () => {
     expect(unknown.response.status).toBe(401);
   });
 
+  test("owner /mcp returns method not found for sessionless server/discover", async () => {
+    const { response, payload } = await mcpPost(
+      API_KEY,
+      { jsonrpc: "2.0", id: 7, method: "server/discover", params: {} },
+      undefined,
+      "/mcp",
+    );
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("mcp-session-id")).toBeNull();
+    expect(payload).toEqual({
+      jsonrpc: "2.0",
+      error: { code: -32601, message: "Method not found" },
+      id: 7,
+    });
+  });
+
   test("owner /mcp path initializes with a known agent and rejects a different X-Agent-ID on the session", async () => {
     const owner = createAgent({ name: "Owner MCP Agent", isLead: false, status: "idle" });
     const other = createAgent({ name: "Other MCP Agent", isLead: false, status: "idle" });

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

@@ -22,6 +22,7 @@ type MetricRunResponse = {
     result: {
       columns: string[];
       rows: Record<string, unknown>[];
+      truncated?: boolean;
     };
   }>;
   result: {
@@ -378,4 +379,47 @@ describe("Metrics HTTP API", () => {
       expect(res.status).toBe(400);
     }
   });
+
+  // Test D (Fix 1, db-query bounded-execution proposal §8): `truncated` still
+  // reaches the metrics response. Metric queries stay on the synchronous
+  // executeReadOnlyQuery path in this change (proposal §5.1's closing note),
+  // so this passes today via runMetricWidget's `total > rows.length` check —
+  // it must keep passing once db-query's other two call sites move to the
+  // bounded path.
+  test("D: a widget whose query returns more rows than maxRows reports truncated: true", async () => {
+    const created = await fetch(`${BASE}/api/metrics/definitions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "truncated-widget",
+        title: "Truncated Widget",
+        definition: {
+          version: 1,
+          widgets: [
+            {
+              id: "many-rows",
+              title: "Many rows",
+              query: {
+                sql: `WITH RECURSIVE cnt(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM cnt WHERE x < 50) SELECT x FROM cnt`,
+                maxRows: 10,
+              },
+              viz: { type: "table" },
+            },
+          ],
+        },
+      }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string };
+
+    const run = await fetch(`${BASE}/api/metrics/definitions/${id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: {} }),
+    });
+    expect(run.status).toBe(200);
+    const runBody = (await run.json()) as MetricRunResponse;
+    expect(runBody.widgets[0]?.result.rows.length).toBe(10);
+    expect(runBody.widgets[0]?.result.truncated).toBe(true);
+  });
 });