@desplega.ai/agent-swarm 1.164.1 → 1.166.0

package/src/tests/kv-view.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+import { resolveKvView, sliceKvTarget, summarizeKvShape } from "../kv-view";
+
+describe("resolveKvView", () => {
+  const stored = JSON.stringify({ a: { rows: [{ id: 0 }, { id: 1 }, { id: 2 }] }, s: "abcdef" });
+
+  test("a JSON string resolves dot paths, numeric segments index arrays", () => {
+    expect(resolveKvView(stored, { path: "a.rows.1.id" })).toEqual({
+      ok: true,
+      value: 1,
+      view: { path: "a.rows.1.id", type: "number" },
+    });
+    expect(resolveKvView(stored, { path: "a.rows", offset: 1, limit: 1 })).toMatchObject({
+      ok: true,
+      value: [{ id: 1 }],
+      view: { total: 3, offset: 1, returned: 1, nextOffset: 2 },
+    });
+  });
+
+  test("objects page by key, strings by character", () => {
+    expect(resolveKvView({ x: 1, y: 2, z: 3 }, { offset: 1, limit: 1 })).toMatchObject({
+      value: { y: 2 },
+      view: { type: "object", total: 3, nextOffset: 2 },
+    });
+    expect(resolveKvView(stored, { path: "s", offset: 2, limit: 3 })).toMatchObject({
+      value: "cde",
+      view: { type: "string", returned: 3, nextOffset: 5 },
+    });
+  });
+
+  test("out-of-range offsets return an empty page with the real total", () => {
+    expect(resolveKvView(stored, { path: "a.rows", offset: 99 })).toMatchObject({
+      ok: true,
+      value: [],
+      view: { total: 3, offset: 99, returned: 0, nextOffset: null },
+    });
+  });
+
+  test("missing keys, bad indices, empty segments and scalar paging are errors", () => {
+    expect(resolveKvView(stored, { path: "a.nope" })).toEqual({
+      ok: false,
+      error: 'path "a.nope" not found: no key "nope" under "a"',
+    });
+    expect(resolveKvView(stored, { path: "a.rows.3" })).toMatchObject({ ok: false });
+    expect(resolveKvView(stored, { path: "a.rows.-1" })).toMatchObject({ ok: false });
+    expect(resolveKvView(stored, { path: "a..rows" })).toMatchObject({ ok: false });
+    expect(resolveKvView(stored, { path: "a.rows.0.id.x" })).toMatchObject({ ok: false });
+    expect(resolveKvView(42, { offset: 1 })).toMatchObject({ ok: false });
+  });
+
+  test("a non-JSON string rejects a path but pages its characters", () => {
+    expect(resolveKvView("plain {not json", { path: "a" })).toMatchObject({ ok: false });
+    expect(resolveKvView("plain {not json", { offset: 6, limit: 5 })).toMatchObject({
+      ok: true,
+      value: "{not ",
+    });
+    // A string holding a JSON scalar stays a plain string.
+    expect(resolveKvView('"quoted"', { offset: 1, limit: 6 })).toMatchObject({ value: "quoted" });
+  });
+
+  test("a string page never ends on a lone high surrogate", () => {
+    const sliced = sliceKvTarget("a🙂b", 0, 2);
+    expect(sliced).toMatchObject({ value: "a", returned: 1, nextOffset: 1 });
+  });
+
+  test("limit 1 on an astral character returns the whole pair and advances", () => {
+    const text = "🙂🙃x";
+    const seen: string[] = [];
+    let offset: number | null = 0;
+    while (offset !== null && seen.length < 10) {
+      const page = sliceKvTarget(text, offset, 1)!;
+      expect(page.returned).toBeGreaterThan(0);
+      seen.push(page.value as string);
+      offset = page.nextOffset;
+    }
+    expect(seen).toEqual(["🙂", "🙃", "x"]);
+  });
+});
+
+describe("summarizeKvShape", () => {
+  test("expands the dominant object down to where the bulk lives", () => {
+    const rows = Array.from({ length: 300 }, (_, id) => ({ id, note: "x".repeat(50) }));
+    const shape = summarizeKvShape({
+      version: 1,
+      toolName: "script-run",
+      outcome: { ok: true, message: "done", data: { status: 200, data: { result: { rows } } } },
+    });
+    expect(shape[0]).toMatchObject({
+      path: "outcome.data.data.result.rows",
+      type: "array",
+      items: 300,
+    });
+    expect(shape[0]!.bytes).toBe(Buffer.byteLength(JSON.stringify(rows)));
+    // Crumbs under 1% of the value are left out.
+    expect(shape.map((entry) => entry.path)).not.toContain("version");
+  });
+
+  test("escapes keys with dots so every shape path resolves", () => {
+    const rows = Array.from({ length: 50 }, (_, id) => ({ id, note: "x".repeat(50) }));
+    const value = { "rows.v2": rows, "a\\b": { "c.d": "y".repeat(2_000) } };
+    const shape = summarizeKvShape(value);
+    expect(shape.map((entry) => entry.path)).toEqual(["rows\\.v2", "a\\\\b.c\\.d"]);
+    for (const entry of shape) {
+      expect(resolveKvView(value, { path: entry.path, offset: 0 })).toMatchObject({
+        ok: true,
+        view: { path: entry.path, type: entry.type, total: entry.items },
+      });
+    }
+  });
+
+  test("keeps long paths exact and replaces unaddressable ones with their nearest ancestor", () => {
+    const rows = Array.from({ length: 80 }, (_, id) => ({ id, note: "x".repeat(60) }));
+    const longKey = "L".repeat(200);
+    expect(summarizeKvShape({ [longKey]: rows })[0]).toMatchObject({ path: longKey, items: 80 });
+    // An empty key has no path syntax: its parent object stands in.
+    expect(summarizeKvShape({ "": rows, small: 1 })[0]).toMatchObject({
+      path: "",
+      type: "object",
+      items: 2,
+    });
+    expect(summarizeKvShape({ outer: { "": rows, side: [1] } })[0]).toMatchObject({
+      path: "outer",
+      type: "object",
+    });
+    // Longer than kv-get's path limit: the root stands in.
+    expect(summarizeKvShape({ ["X".repeat(1_100)]: rows })[0]).toMatchObject({ path: "" });
+  });
+
+  test("is bounded by total path bytes", () => {
+    const value = Object.fromEntries(
+      Array.from({ length: 8 }, (_, i) => [`${i}`.repeat(600), "v".repeat(1_000)]),
+    );
+    const shape = summarizeKvShape(value);
+    const pathBytes = shape.reduce((sum, entry) => sum + JSON.stringify(entry.path).length, 0);
+    expect(pathBytes).toBeLessThanOrEqual(2_048);
+    expect(shape.filter((entry) => entry.path.length === 600)).toHaveLength(3);
+    expect(shape.at(-1)).toMatchObject({ path: "", type: "object", items: 8 });
+  });
+
+  test("is bounded to maxEntries", () => {
+    const wide = Object.fromEntries(
+      Array.from({ length: 50 }, (_, i) => [`k${i}`, "v".repeat(100)]),
+    );
+    expect(summarizeKvShape(wide)).toHaveLength(8);
+    expect(summarizeKvShape(wide, 3)).toHaveLength(3);
+  });
+});

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

@@ -9,17 +9,20 @@ import {
 import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import {
   closeDb,
+  completeTask,
   createAgent,
   createTaskExtended,
   createUser,
   getDbClient,
   getTaskById,
   initDb,
+  startTask,
 } from "../be/db";
 import { type IdentityActor, mintToken, revokeToken } from "../be/users";
 import { handleCore } from "../http/core";
 import { handleMcp } from "../http/mcp";
 import { handleMcpUser } from "../http/mcp-user";
+import { handlePoll } from "../http/poll";
 import { listenOnFreePort } from "./test-net";
 
 const TEST_DB_PATH = "./test-mcp-user-route.sqlite";
@@ -80,6 +83,7 @@ beforeEach(async () => {
   await client.run("DELETE FROM user_tokens");
   await client.run("DELETE FROM agent_tasks");
   await client.run("DELETE FROM users");
+  await client.run("DELETE FROM agents");
 });
 
 function endpoint(path = "/mcp-user"): string {
@@ -125,6 +129,32 @@ async function mcpPost(
   return { response, payload, text };
 }
 
+async function callPoll(agentId: string): Promise<{
+  status: number;
+  body: { trigger: { type: string; [key: string]: unknown } | null } | { error: string };
+}> {
+  let status = 200;
+  let bodyStr = "";
+  const req = {
+    method: "GET",
+    url: "/api/poll",
+    headers: { "x-agent-id": agentId },
+  } as unknown as Parameters<typeof handlePoll>[0];
+  const res = {
+    setHeader() {},
+    writeHead(code: number) {
+      status = code;
+    },
+    end(body?: string) {
+      bodyStr = body ?? "";
+    },
+  } as unknown as Parameters<typeof handlePoll>[1];
+
+  const handled = await handlePoll(req, res, ["api", "poll"], new URLSearchParams(), agentId);
+  if (!handled) throw new Error("handlePoll did not handle the request");
+  return { status, body: bodyStr ? JSON.parse(bodyStr) : { trigger: null } };
+}
+
 async function initialize(
   token: string,
   path = "/mcp-user",
@@ -237,7 +267,7 @@ describe("/mcp-user auth and tool surface", () => {
     expect(response.status).toBe(401);
   });
 
-  test("valid active-user token initializes and tools/list returns exactly the 6 task tools", async () => {
+  test("valid active-user token initializes and exposes the narrow send-task schema", async () => {
     const user = await createUser({ name: "Active User" });
     const token = (await mintToken(user.id, "active", ACTOR)).plaintext;
     const sessionId = await initialize(token);
@@ -250,23 +280,106 @@ describe("/mcp-user auth and tool surface", () => {
     );
 
     expect(response.status).toBe(200);
-    const result = payload as { result: { tools: Array<{ name: string }> } };
+    const result = payload as {
+      result: {
+        tools: Array<{ name: string; inputSchema: { properties?: Record<string, unknown> } }>;
+      };
+    };
     const names = result.result.tools.map((tool) => tool.name).sort();
     expect(names).toEqual(
-      [
-        "cancel-task",
-        "get-task-details",
-        "get-tasks",
-        "send-task",
-        "steer-task",
-        "task-action",
-      ].sort(),
+      ["cancel-task", "get-task-details", "get-tasks", "send-task", "steer-task"].sort(),
+    );
+    const sendTask = result.result.tools.find((tool) => tool.name === "send-task");
+    expect(Object.keys(sendTask?.inputSchema.properties ?? {}).sort()).toEqual(
+      ["model", "modelTier", "outputSchema", "priority", "tags", "task", "taskType"].sort(),
     );
   });
 
-  test("send-task over /mcp-user records requestedByUserId and get-tasks returns only that user's tasks", async () => {
+  test("send-task assigns user work to the Lead with internal routing proof", async () => {
+    const lead = await createAgent({
+      id: "10000000-0000-4000-8000-000000000001",
+      name: "User MCP Lead",
+      isLead: true,
+      status: "idle",
+    });
+    const user = await createUser({ name: "Lead Requester" });
+    const token = (await mintToken(user.id, "lead-route", ACTOR)).plaintext;
+    const sessionId = await initialize(token);
+    await notifyInitialized(token, sessionId);
+
+    const { response, payload } = await mcpPost(
+      token,
+      {
+        jsonrpc: "2.0",
+        id: 3,
+        method: "tools/call",
+        params: { name: "send-task", arguments: { task: "route this through the lead" } },
+      },
+      sessionId,
+    );
+
+    expect(response.status).toBe(200);
+    const result = payload as { result: { structuredContent: { task: { id: string } } } };
+    const task = await getTaskById(result.result.structuredContent.task.id);
+    expect(task).toMatchObject({
+      status: "pending",
+      agentId: lead.id,
+      requestedByUserId: user.id,
+      routingReason: "skill",
+      routingSource: "engine_default",
+      routingNote: "User MCP ingress assigns new work to the Lead for delegation.",
+    });
+    expect(task?.offeredTo).toBeUndefined();
+    expect(task?.routingAffinity).toBeUndefined();
+  });
+
+  test("send-task queues for a busy Lead and poll starts it after capacity returns", async () => {
+    const lead = await createAgent({
+      id: "10000000-0000-4000-8000-000000000002",
+      name: "Busy User MCP Lead",
+      isLead: true,
+      status: "idle",
+      maxTasks: 1,
+    });
+    const activeTask = await createTaskExtended("existing lead work", { agentId: lead.id });
+    expect((await startTask(activeTask.id))?.status).toBe("in_progress");
+    const user = await createUser({ name: "Busy Lead Requester" });
+    const token = (await mintToken(user.id, "busy-lead-route", ACTOR)).plaintext;
+    const sessionId = await initialize(token);
+    await notifyInitialized(token, sessionId);
+
+    const { payload } = await mcpPost(
+      token,
+      {
+        jsonrpc: "2.0",
+        id: 3,
+        method: "tools/call",
+        params: { name: "send-task", arguments: { task: "wait for the busy lead" } },
+      },
+      sessionId,
+    );
+
+    const result = payload as { result: { structuredContent: { task: { id: string } } } };
+    const task = await getTaskById(result.result.structuredContent.task.id);
+    expect(task).toMatchObject({ status: "pending", agentId: lead.id });
+
+    const blockedPoll = await callPoll(lead.id);
+    expect(blockedPoll.status).toBe(200);
+    if ("error" in blockedPoll.body) throw new Error("unexpected poll error");
+    expect(blockedPoll.body.trigger).toBeNull();
+    expect((await getTaskById(task!.id))?.status).toBe("pending");
+
+    await completeTask(activeTask.id, "capacity returned");
+    const readyPoll = await callPoll(lead.id);
+    expect(readyPoll.status).toBe(200);
+    if ("error" in readyPoll.body) throw new Error("unexpected poll error");
+    expect(readyPoll.body.trigger?.type).toBe("task_assigned");
+    expect((readyPoll.body.trigger as { taskId: string }).taskId).toBe(task?.id);
+    expect((await getTaskById(task!.id))?.status).toBe("in_progress");
+  });
+
+  test("send-task refuses with no Lead and creates no task", async () => {
     const user = await createUser({ name: "Task Requester" });
-    const otherUser = await createUser({ name: "Other Task Requester" });
     const token = (await mintToken(user.id, "task", ACTOR)).plaintext;
     const sessionId = await initialize(token);
     await notifyInitialized(token, sessionId);
@@ -283,9 +396,81 @@ describe("/mcp-user auth and tool surface", () => {
     );
 
     expect(response.status).toBe(200);
-    const result = payload as { result: { structuredContent: { task: { id: string } } } };
-    const taskId = result.result.structuredContent.task.id;
-    expect((await getTaskById(taskId))?.requestedByUserId).toBe(user.id);
+    const result = payload as {
+      result: { isError?: boolean; structuredContent: { success: boolean; message: string } };
+    };
+    expect(result.result.isError).toBe(true);
+    expect(result.result.structuredContent).toMatchObject({
+      success: false,
+      message: "No online Lead is available. Start or register a Lead before sending a task.",
+    });
+    expect(
+      (await getDbClient().get<{ count: number }>("SELECT COUNT(*) AS count FROM agent_tasks"))
+        ?.count,
+    ).toBe(0);
+  });
+
+  test("send-task refuses with only an offline Lead and creates no task", async () => {
+    await createAgent({
+      id: "10000000-0000-4000-8000-000000000004",
+      name: "Offline User MCP Lead",
+      isLead: true,
+      status: "offline",
+    });
+    const user = await createUser({ name: "Offline Lead Requester" });
+    const token = (await mintToken(user.id, "offline-lead", ACTOR)).plaintext;
+    const sessionId = await initialize(token);
+    await notifyInitialized(token, sessionId);
+
+    const { payload } = await mcpPost(
+      token,
+      {
+        jsonrpc: "2.0",
+        id: 3,
+        method: "tools/call",
+        params: { name: "send-task", arguments: { task: "do not queue without a Lead" } },
+      },
+      sessionId,
+    );
+
+    const result = payload as {
+      result: { isError?: boolean; structuredContent: { success: boolean; message: string } };
+    };
+    expect(result.result.isError).toBe(true);
+    expect(result.result.structuredContent.success).toBe(false);
+    expect(
+      (await getDbClient().get<{ count: number }>("SELECT COUNT(*) AS count FROM agent_tasks"))
+        ?.count,
+    ).toBe(0);
+  });
+
+  test("send-task preserves requester ownership and get-tasks filters foreign work", async () => {
+    const lead = await createAgent({ name: "Ownership Lead", isLead: true, status: "idle" });
+    const user = await createUser({ name: "Task Requester" });
+    const otherUser = await createUser({ name: "Other Task Requester" });
+    const token = (await mintToken(user.id, "task-ownership", ACTOR)).plaintext;
+    const sessionId = await initialize(token);
+    await notifyInitialized(token, sessionId);
+
+    const sent = await mcpPost(
+      token,
+      {
+        jsonrpc: "2.0",
+        id: 3,
+        method: "tools/call",
+        params: { name: "send-task", arguments: { task: "owned user mcp task" } },
+      },
+      sessionId,
+    );
+    const sentResult = sent.payload as {
+      result: { structuredContent: { task: { id: string } } };
+    };
+    const taskId = sentResult.result.structuredContent.task.id;
+    expect(await getTaskById(taskId)).toMatchObject({
+      status: "pending",
+      agentId: lead.id,
+      requestedByUserId: user.id,
+    });
     const foreignTask = await createTaskExtended("foreign user mcp task", {
       requestedByUserId: otherUser.id,
     });
@@ -312,6 +497,63 @@ describe("/mcp-user auth and tool surface", () => {
     expect(listResult.result.structuredContent.tasks).toHaveLength(1);
   });
 
+  test("send-task ignores injected routing fields and keeps internal routing authoritative", async () => {
+    const lead = await createAgent({
+      id: "10000000-0000-4000-8000-000000000003",
+      name: "Authoritative User MCP Lead",
+      isLead: true,
+      status: "idle",
+    });
+    const attacker = await createAgent({
+      id: "20000000-0000-4000-8000-000000000001",
+      name: "Injected Target",
+      isLead: false,
+      status: "idle",
+    });
+    const user = await createUser({ name: "Injection Requester" });
+    const foreignUser = await createUser({ name: "Foreign Requester" });
+    const token = (await mintToken(user.id, "routing-injection", ACTOR)).plaintext;
+    const sessionId = await initialize(token);
+    await notifyInitialized(token, sessionId);
+
+    const { response, payload } = await mcpPost(
+      token,
+      {
+        jsonrpc: "2.0",
+        id: 3,
+        method: "tools/call",
+        params: {
+          name: "send-task",
+          arguments: {
+            task: "keep server routing authoritative",
+            agentId: attacker.id,
+            routingReason: "human_pinned",
+            routingNote: "Injected routing note must not survive.",
+            offerMode: false,
+            leadOnly: true,
+            allowDuplicate: true,
+            requestedByUserId: foreignUser.id,
+          },
+        },
+      },
+      sessionId,
+    );
+
+    expect(response.status).toBe(200);
+    const result = payload as { result: { structuredContent: { task: { id: string } } } };
+    const task = await getTaskById(result.result.structuredContent.task.id);
+    expect(task).toMatchObject({
+      status: "pending",
+      agentId: lead.id,
+      requestedByUserId: user.id,
+      routingReason: "skill",
+      routingSource: "engine_default",
+      routingNote: "User MCP ingress assigns new work to the Lead for delegation.",
+    });
+    expect(task?.offeredTo).toBeUndefined();
+    expect(task?.routingAffinity?.leadOnly).not.toBe(true);
+  });
+
   test("owner /mcp initialize requires a known X-Agent-ID", async () => {
     const missing = await mcpPost(
       API_KEY,

package/src/tests/memory-injection-outcome.test.ts

@@ -0,0 +1,143 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
+import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
+import { memorySnippet, renderMemoriesPrompt } from "../prompts/memories";
+
+const longPrompt = `Implement the thing. ${"Background detail that is not the outcome. ".repeat(12)}`;
+
+describe("renderMemoriesPrompt — outcome, date and source", () => {
+  test("a task_completion line shows the output, not the start of a >300-char prompt", () => {
+    expect(longPrompt.length).toBeGreaterThan(300);
+    const prompt = renderMemoriesPrompt([
+      {
+        id: "m-1",
+        name: "Task: Implement the thing",
+        content: `Task: ${longPrompt}\n\nOutput:\nShipped PR #42; tests green.`,
+        similarity: 0.9,
+        source: "task_completion",
+        createdAt: "2026-09-29T07:20:00.000Z",
+      },
+    ]);
+    expect(prompt).toContain(
+      "- [2026-09-29, task_completion] **Task: Implement the thing** (id: m-1): Shipped PR #42; tests green.",
+    );
+    expect(prompt).not.toContain("Background detail");
+  });
+
+  test("a failed task_completion shows the failure reason without the boilerplate tail", () => {
+    const snippet = memorySnippet({
+      id: "m-2",
+      name: "x",
+      content: `Task: ${longPrompt}\n\nFailure reason:\nCI red on main.\n\nThis task failed. Learn from this to avoid repeating the mistake.`,
+      similarity: 0.9,
+      source: "task_completion",
+    });
+    expect(snippet).toBe("FAILED: CI red on main.");
+  });
+
+  test("the last Output marker wins when the task prompt embeds an earlier one", () => {
+    const snippet = memorySnippet({
+      id: "m-3",
+      name: "x",
+      content:
+        'Task: Worker task completed.\nTask: "y"\n\nOutput:\nold worker output\n\nOutput:\nreview done',
+      similarity: 0.9,
+      source: "task_completion",
+    });
+    expect(snippet).toBe("review done");
+  });
+
+  test("summary wins when set; other sources keep their content; missing metadata adds no prefix", () => {
+    expect(
+      memorySnippet({
+        id: "m-4",
+        name: "x",
+        content: `Task: ${longPrompt}\n\nOutput:\nlong output`,
+        similarity: 0.9,
+        source: "task_completion",
+        summary: "  short summary  ",
+      }),
+    ).toBe("short summary");
+    const prompt = renderMemoriesPrompt([
+      { id: "m-5", name: "manual note", content: "Output:\nkeep me", similarity: 0.9 },
+    ]);
+    expect(prompt).toContain("- **manual note** (id: m-5): Output:\nkeep me");
+  });
+});
+
+describe("200_backfill_auto_memory_expiry", () => {
+  const TEST_DB_PATH = "./test-memory-injection-outcome.sqlite";
+  const agentId = crypto.randomUUID();
+  let store: SqliteMemoryStore;
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    await createAgent({ id: agentId, name: "Backfill Agent", isLead: false, status: "idle" });
+    store = new SqliteMemoryStore();
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+  });
+
+  test("sets a 7-day expiry on legacy agent-scope auto memories only", async () => {
+    const base = { agentId, name: "m", content: "Task: x\n\nOutput:\ny" };
+    const completion = await store.store({ ...base, scope: "agent", source: "task_completion" });
+    const session = await store.store({ ...base, scope: "agent", source: "session_summary" });
+    const swarm = await store.store({ ...base, scope: "swarm", source: "task_completion" });
+    const manual = await store.store({ ...base, scope: "agent", source: "manual" });
+    const longterm = await store.store({
+      ...base,
+      scope: "agent",
+      source: "task_completion",
+      key: "/longterm/facts/backfill/keep",
+    });
+    const alreadySet = await store.store({ ...base, scope: "agent", source: "task_completion" });
+
+    const db = getDbClient();
+    const legacy = [completion, session, swarm, manual, longterm];
+    for (const row of legacy) {
+      await db.run("UPDATE agent_memory SET expiresAt = NULL WHERE id = ?", [row.id]);
+    }
+    const presetExpiry = "2099-01-01T00:00:00.000Z";
+    await db.run("UPDATE agent_memory SET expiresAt = ? WHERE id = ?", [
+      presetExpiry,
+      alreadySet.id,
+    ]);
+
+    const sql = await Bun.file(
+      new URL("../be/migrations/200_backfill_auto_memory_expiry.sql", import.meta.url),
+    ).text();
+    const before = Date.now();
+    await db.run(sql);
+
+    const expiry = async (id: string) =>
+      (
+        await db.get<{ expiresAt: string | null }>(
+          "SELECT expiresAt FROM agent_memory WHERE id = ?",
+          [id],
+        )
+      )?.expiresAt ?? null;
+
+    for (const row of [completion, session]) {
+      const value = await expiry(row.id);
+      expect(value).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      const days = (Date.parse(value!) - before) / 86_400_000;
+      expect(days).toBeGreaterThan(6.99);
+      expect(days).toBeLessThan(7.01);
+    }
+    for (const row of [swarm, manual, longterm]) expect(await expiry(row.id)).toBeNull();
+    expect(await expiry(alreadySet.id)).toBe(presetExpiry);
+  });
+});