@desplega.ai/agent-swarm 1.157.0 → 1.158.0

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

@@ -573,7 +573,8 @@ describe("Tasks", () => {
     expect(status).toBe(200);
     expect(body.tasks).toBeDefined();
     expect(Array.isArray(body.tasks)).toBe(true);
-    expect(body.total).toBeGreaterThanOrEqual(2);
+    // `total` is an opt-in COUNT(*): omitted unless `includeTotal=true`.
+    expect(body.total).toBeUndefined();
   });
 
   test("GET /api/tasks?status=pending — filter by status", async () => {
@@ -599,12 +600,25 @@ describe("Tasks", () => {
   });
 
   test("GET /api/tasks?limit=1 — pagination", async () => {
-    const { status, body } = await get("/api/tasks?limit=1");
+    const { status, body } = await get("/api/tasks?limit=1&includeTotal=true");
     expect(status).toBe(200);
     expect(body.tasks.length).toBe(1);
     expect(body.total).toBeGreaterThanOrEqual(2);
   });
 
+  test("GET /api/tasks?fields=timeline — narrow timeline rows", async () => {
+    const { status, body } = await get("/api/tasks?fields=timeline&orderBy=createdAt&limit=5");
+    expect(status).toBe(200);
+    expect(body.tasks.length).toBeGreaterThanOrEqual(1);
+    for (const t of body.tasks) {
+      expect(typeof t.id).toBe("string");
+      expect(typeof t.status).toBe("string");
+      expect(t.progress).toBeUndefined();
+      expect(t.tags).toBeUndefined();
+    }
+    expect(body.total).toBeUndefined();
+  });
+
   test("GET /api/tasks/:id — get specific task", async () => {
     const { status, body } = await get(`/api/tasks/${ids.task}`);
     expect(status).toBe(200);

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

@@ -9,7 +9,9 @@ import {
   getKv,
   incrKv,
   initDb,
+  type KvJsonFieldEquals,
   KvTypeCollisionError,
+  kvPrefixUpperBound,
   listKv,
   sweepExpiredKv,
   sweepExpiredKvPrefix,
@@ -200,6 +202,66 @@ describe("kv-storage helpers", () => {
     expect(exact.map((e) => e.key)).toEqual(["x_1"]);
   });
 
+  test("listKv prefix is an exact, case-sensitive range on the primary key", async () => {
+    for (const key of ["m/row/1", "m/row/2", "M/row/3", "m/rowx", "m/row", "n/row/1", "m/row/é"]) {
+      await upsertKv({ namespace: NS, key, value: 1, valueType: "integer" });
+    }
+    const rows = await listKv(NS, { prefix: "m/row/", limit: 100, offset: 0 });
+    expect(rows.map((e) => e.key)).toEqual(["m/row/1", "m/row/2", "m/row/é"]);
+    expect(await countKv(NS, { prefix: "m/row/" })).toBe(3);
+    expect(kvPrefixUpperBound("m/row/")).toBe("m/row0");
+    expect(kvPrefixUpperBound(`a${String.fromCodePoint(0x10ffff)}`)).toBe("b");
+    expect(kvPrefixUpperBound(String.fromCodePoint(0xd7ff))).toBe(String.fromCodePoint(0xe000));
+
+    const plan = await getDbClient().query<{ detail: string }>(
+      `EXPLAIN QUERY PLAN SELECT key FROM kv_entries
+        WHERE namespace = ? AND (expires_at IS NULL OR expires_at > ?) AND key >= ? AND key < ?`,
+      [NS, 0, "m/row/", "m/row0"],
+    );
+    expect(plan.map((row) => row.detail).join(" ")).toContain("key>? AND key<?");
+  });
+
+  test("listKv jsonFieldEquals narrows rows in SQL and skips corrupt JSON", async () => {
+    await upsertKv({
+      namespace: NS,
+      key: "r/1",
+      value: { run: "a", ok: true, n: 2 },
+      valueType: "json",
+    });
+    await upsertKv({
+      namespace: NS,
+      key: "r/2",
+      value: { run: "b", ok: false, n: 2 },
+      valueType: "json",
+    });
+    await upsertKv({
+      namespace: NS,
+      key: "r/3",
+      value: { run: "a", ok: false, n: 3.5 },
+      valueType: "json",
+    });
+    await getDbClient().run(
+      "INSERT INTO kv_entries (namespace, key, value, value_type) VALUES (?, ?, ?, 'json')",
+      [NS, "r/4", "{not json"],
+    );
+    const keys = async (jsonFieldEquals: KvJsonFieldEquals[]) =>
+      (await listKv(NS, { prefix: "r/", limit: 100, offset: 0, jsonFieldEquals })).map(
+        (e) => e.key,
+      );
+    expect(await keys([])).toEqual(["r/1", "r/2", "r/3", "r/4"]);
+    expect(await keys([{ field: "run", value: "a" }])).toEqual(["r/1", "r/3"]);
+    expect(await keys([{ field: "ok", value: true }])).toEqual(["r/1"]);
+    // Non-safe-integer numbers are not prefiltered (the caller re-checks).
+    expect(await keys([{ field: "n", value: 3.5 }])).toEqual(["r/1", "r/2", "r/3", "r/4"]);
+    expect(
+      await keys([
+        { field: "run", value: "a" },
+        { field: "n", value: 2 },
+      ]),
+    ).toEqual(["r/1"]);
+    expect(await keys([{ field: "missing", value: "a" }])).toEqual([]);
+  });
+
   test("incrKv creates from missing", async () => {
     const entry = await incrKv(NS, "counter", 3);
     expect(entry.value).toBe(3);

package/src/tests/linear-outbound-sync.test.ts

@@ -2,7 +2,12 @@ import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, mock, tes
 import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
 import { createTrackerSync, getTrackerSync, updateTrackerSync } from "../be/db-queries/tracker";
-import { initLinearOutboundSync, teardownLinearOutboundSync } from "../linear/outbound";
+import {
+  formatLinearOutcomeBody,
+  initLinearOutboundSync,
+  LINEAR_BODY_MAX,
+  teardownLinearOutboundSync,
+} from "../linear/outbound";
 import { taskSessionMap } from "../linear/sync";
 import { workflowEventBus } from "../workflows/event-bus";
 
@@ -79,8 +84,8 @@ describe("Linear Outbound Sync", () => {
     const callArgs = mockCreateComment.mock.calls[0] as unknown[];
     const arg = callArgs[0] as { issueId: string; body: string };
     expect(arg.issueId).toBe("LIN-OUT-COMPLETED");
-    expect(arg.body).toContain("Task completed");
-    expect(arg.body).toContain("All done!");
+    // The output is the whole comment: no boilerplate, no collapsed `+++` section.
+    expect(arg.body).toBe("All done!");
 
     // Verify sync record updated
     const updated = await getTrackerSync("linear", "task", "outbound-task-completed");
@@ -107,8 +112,118 @@ describe("Linear Outbound Sync", () => {
     const callArgs = mockCreateComment.mock.calls[0] as unknown[];
     const arg = callArgs[0] as { issueId: string; body: string };
     expect(arg.issueId).toBe("LIN-OUT-FAILED");
-    expect(arg.body).toContain("Task failed");
-    expect(arg.body).toContain("Build error in module X");
+    expect(arg.body).toBe("Task failed.\n\nBuild error in module X");
+  });
+
+  test("task.completed with an AgentSession posts ONE response activity carrying the full output", async () => {
+    const taskId = "outbound-session-completed";
+    await createTrackerSync({
+      provider: "linear",
+      entityType: "task",
+      swarmId: taskId,
+      externalId: "LIN-OUT-SESSION-COMPLETED",
+      syncDirection: "bidirectional",
+    });
+    taskSessionMap.set(taskId, "session-completed");
+    // Longer than the old 2000-char cut, shorter than the Linear body cap.
+    const output = `## Answer\n\n${"x".repeat(5000)}`;
+
+    workflowEventBus.emit("task.completed", { taskId, output });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockEndAgentSession).toHaveBeenCalledTimes(1);
+    expect(mockEndAgentSession.mock.calls[0] as unknown[]).toEqual([
+      "session-completed",
+      output,
+      "response",
+    ]);
+    expect(mockCreateComment).not.toHaveBeenCalled();
+    expect(taskSessionMap.has(taskId)).toBe(false);
+  });
+
+  test("task.failed with an AgentSession posts ONE error activity with the plain reason", async () => {
+    const taskId = "outbound-session-failed";
+    await createTrackerSync({
+      provider: "linear",
+      entityType: "task",
+      swarmId: taskId,
+      externalId: "LIN-OUT-SESSION-FAILED",
+      syncDirection: "bidirectional",
+    });
+    taskSessionMap.set(taskId, "session-failed");
+
+    workflowEventBus.emit("task.failed", { taskId, failureReason: "tsc:check failed" });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockEndAgentSession).toHaveBeenCalledTimes(1);
+    expect(mockEndAgentSession.mock.calls[0] as unknown[]).toEqual([
+      "session-failed",
+      "Task failed.\n\ntsc:check failed",
+      "error",
+    ]);
+    expect(mockCreateComment).not.toHaveBeenCalled();
+  });
+
+  test("task.completed with no output still ends the session with a short body", async () => {
+    const taskId = "outbound-session-empty";
+    await createTrackerSync({
+      provider: "linear",
+      entityType: "task",
+      swarmId: taskId,
+      externalId: "LIN-OUT-SESSION-EMPTY",
+      syncDirection: "bidirectional",
+    });
+    taskSessionMap.set(taskId, "session-empty");
+
+    workflowEventBus.emit("task.completed", { taskId, output: "  " });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(mockEndAgentSession.mock.calls[0] as unknown[]).toEqual([
+      "session-empty",
+      "Task completed.",
+      "response",
+    ]);
+  });
+
+  describe("formatLinearOutcomeBody", () => {
+    const savedDashboard = process.env.SWARM_DASHBOARD_URL;
+    const savedApp = process.env.APP_URL;
+
+    afterEach(() => {
+      if (savedDashboard === undefined) delete process.env.SWARM_DASHBOARD_URL;
+      else process.env.SWARM_DASHBOARD_URL = savedDashboard;
+      if (savedApp === undefined) delete process.env.APP_URL;
+      else process.env.APP_URL = savedApp;
+    });
+
+    test("returns text at the cap unchanged", () => {
+      const text = "a".repeat(LINEAR_BODY_MAX);
+      expect(formatLinearOutcomeBody(text, "t1")).toBe(text);
+    });
+
+    test("caps oversized text with a visible note linking the swarm task", () => {
+      delete process.env.SWARM_DASHBOARD_URL;
+      process.env.APP_URL = "https://swarm.example.com/";
+      const text = "b".repeat(LINEAR_BODY_MAX + 500);
+
+      const body = formatLinearOutcomeBody(text, "task-123");
+
+      expect(body.length).toBeLessThanOrEqual(LINEAR_BODY_MAX);
+      expect(body.startsWith("b".repeat(1000))).toBe(true);
+      expect(body).toContain(`of ${text.length} characters`);
+      expect(body.endsWith("Full text: https://swarm.example.com/tasks/task-123_")).toBe(true);
+      expect(body).not.toContain("+++");
+    });
+
+    test("names the task id when no dashboard URL is configured", () => {
+      delete process.env.SWARM_DASHBOARD_URL;
+      delete process.env.APP_URL;
+
+      const body = formatLinearOutcomeBody("c".repeat(LINEAR_BODY_MAX + 1), "task-456");
+
+      expect(body.length).toBeLessThanOrEqual(LINEAR_BODY_MAX);
+      expect(body.endsWith("Full text: swarm task `task-456`_")).toBe(true);
+    });
   });
 
   test("no-op when no tracker_sync mapping exists", async () => {

package/src/tests/list-endpoint-slimming.test.ts

@@ -11,6 +11,7 @@ import {
   getAgentById,
   getAllAgents,
   getAllTasks,
+  getDbClient,
   getScheduledTasks,
   initDb,
   listAllPages,
@@ -227,6 +228,96 @@ describe("list-endpoint slimming", () => {
     expect(full?.totalCostUsd).toBeCloseTo(0.0168, 6);
   });
 
+  test("getAllTasks — SQL-side preview matches truncating the full text", async () => {
+    // The SQL cut counts UTF-8 bytes while JS slices UTF-16 units, so pin the
+    // boundary with astral (surrogate-pair) and multibyte characters. SQLite's
+    // text functions stop at an embedded NUL, so pin that too, plus a leading
+    // BOM a default TextDecoder would strip. The BOM goes in as SQL bytes:
+    // bun:sqlite drops a leading BOM when it binds a string.
+    const agentId = "preview-parity-agent";
+    const marker = "preview-parity-";
+    const texts = [
+      `${marker}${"a".repeat(285)}`, // exactly 300 units
+      `${marker}${"a".repeat(286)}`, // 301 units
+      `${marker}${"😀".repeat(200)}`,
+      `${marker}${"é".repeat(284)}😀`,
+      `${marker}${"ñ".repeat(500)}`,
+      `${marker}short`,
+      "a\u0000b",
+      `\u0000${"x".repeat(350)}`,
+    ];
+    for (const text of texts) await createTaskExtended(text, { agentId });
+    const bom = await createTaskExtended(`${marker}bom`, { agentId });
+    texts.push(`\uFEFF${marker}bom`);
+    await getDbClient().run(
+      "UPDATE agent_tasks SET task = CAST(x'EFBBBF' AS TEXT) || task WHERE id = ?",
+      [bom.id],
+    );
+
+    const full = await getAllTasks({ agentId, limit: 50 });
+    expect(full.map((t) => t.task).sort()).toEqual([...texts].sort());
+    for (const opts of [{ slim: true }, { fields: "timeline" as const }]) {
+      const rows = await getAllTasks({ agentId, limit: 50 }, opts);
+      expect(rows.map((t) => t.id)).toEqual(full.map((t) => t.id));
+      for (const [i, row] of full.entries()) {
+        const expected = row.task.length > 300 ? `${row.task.slice(0, 300)}…` : row.task;
+        expect(rows[i]!.task).toBe(expected);
+      }
+    }
+  });
+
+  test("getAllTasks — slim and full pages hold the same rows in the same order", async () => {
+    for (let i = 0; i < 12; i++) {
+      await createTaskExtended(`page-parity ${i}`, { agentId: "slim-agent-1" });
+    }
+    for (const orderBy of ["lastUpdatedAt", "createdAt"] as const) {
+      for (const offset of [0, 5, 10]) {
+        const filters = { search: "page-parity", limit: 5, offset, orderBy };
+        const slimIds = (await getAllTasks(filters, { slim: true })).map((t) => t.id);
+        const fullIds = (await getAllTasks(filters)).map((t) => t.id);
+        const timelineIds = (await getAllTasks(filters, { fields: "timeline" })).map((t) => t.id);
+        expect(slimIds).toEqual(fullIds);
+        expect(timelineIds).toEqual(fullIds);
+      }
+    }
+  });
+
+  test("getAllTasks — timeline projection carries only what the timeline draws", async () => {
+    const task = await createTaskExtended(`timeline-row ${"T".repeat(1000)}`, {
+      agentId: "slim-agent-1",
+      tags: ["timeline"],
+    });
+    await createSessionCost({
+      sessionId: "timeline-cost-session",
+      taskId: task.id,
+      agentId: "slim-agent-1",
+      totalCostUsd: 0.25,
+      durationMs: 1000,
+      numTurns: 1,
+      model: "test-model",
+    });
+
+    const [row] = await getAllTasks({ search: "timeline-row", limit: 1 }, { fields: "timeline" });
+    expect(Object.keys(row!).sort()).toEqual(
+      [
+        "agentId",
+        "createdAt",
+        "finishedAt",
+        "id",
+        "lastUpdatedAt",
+        "parentTaskId",
+        "peakContextTokens",
+        "status",
+        "task",
+        "title",
+        "totalCostUsd",
+      ].sort(),
+    );
+    expect(row!.id).toBe(task.id);
+    expect(row!.task).toBe(`${task.task.slice(0, 300)}…`);
+    expect(row!.totalCostUsd).toBeCloseTo(0.25, 6);
+  });
+
   test("listRecentSessions — slim root is a truncated task summary", async () => {
     const longText = "Q".repeat(2000);
     await createTaskExtended(longText, { agentId: "slim-agent-1" });

package/src/tests/memory-graph-organic-route.test.ts

@@ -0,0 +1,155 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import { unlink } from "node:fs/promises";
+import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
+import { expandCandidatesWithGraph } from "../be/memory/graph-expansion";
+import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
+import { computeScore, rerank } from "../be/memory/reranker";
+
+// PR #1689 review on 2e8c2f24: expansion replaced an organic duplicate with
+// its graph route on the UNCAPPED graph score, then rerank() capped that route
+// at a low-quality parent's composite. The neighbour's stronger organic match
+// was gone. Fresh rows, default boosts, link strength 1, vector-only arm so
+// each similarity is the fixture cosine:
+// - task_completion parent: relevance 0.90, composite 0.90 x 0.7 = 0.63
+// - manual neighbour, also a direct match: relevance 0.60, composite 0.90
+// - unrelated manual row: relevance 0.54, composite 0.81
+
+const TEST_DB_PATH = "./test-memory-graph-organic-route.sqlite";
+const agentId = randomUUID();
+
+/** Unit vector: `cos` on axis 2 (the query axis), the remainder on `axis`. */
+function mix(cos: number, axis: number): Float32Array {
+  const embedding = new Float32Array(512);
+  embedding[2] = cos;
+  embedding[axis] = Math.sqrt(1 - cos * cos);
+  return embedding;
+}
+
+const queryEmbedding = mix(1, 3);
+
+let parentId: string;
+let neighborId: string;
+let otherId: string;
+let prevHybridFlag: string | undefined;
+let prevGraphFlag: string | undefined;
+
+async function searchAndExpand() {
+  const candidates = await new SqliteMemoryStore().search(queryEmbedding, agentId, {
+    scope: "all",
+    limit: 15,
+  });
+  const expanded = await expandCandidatesWithGraph(candidates, agentId, { scope: "all" });
+  return { candidates, expanded };
+}
+
+beforeAll(async () => {
+  prevHybridFlag = process.env.MEMORY_HYBRID_SEARCH;
+  prevGraphFlag = process.env.MEMORY_GRAPH_EXPANSION;
+  process.env.MEMORY_HYBRID_SEARCH = "0";
+  delete process.env.MEMORY_GRAPH_EXPANSION;
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+  initDb(TEST_DB_PATH);
+  await createAgent({ id: agentId, name: "Organic Route Agent", isLead: false, status: "idle" });
+
+  const store = new SqliteMemoryStore();
+  const parent = await store.store({
+    agentId,
+    scope: "agent",
+    name: "completed task summary",
+    content: "What the task did.",
+    source: "task_completion",
+  });
+  parentId = parent.id;
+  await store.updateEmbedding(parentId, mix(0.9, 4), "test");
+
+  const neighbor = await store.store({
+    agentId,
+    scope: "agent",
+    name: "manual note linked from the summary",
+    content: "A manual note that also matches the query directly.",
+    source: "manual",
+  });
+  neighborId = neighbor.id;
+  await store.updateEmbedding(neighborId, mix(0.6, 5), "test");
+
+  const other = await store.store({
+    agentId,
+    scope: "agent",
+    name: "unrelated manual note",
+    content: "Another manual note.",
+    source: "manual",
+  });
+  otherId = other.id;
+  await store.updateEmbedding(otherId, mix(0.54, 6), "test");
+
+  const nowIso = new Date().toISOString();
+  await getDbClient().run(
+    `INSERT INTO memory_link
+       (id, from_memory_id, linkType, targetKind, targetId, strength, resolver, sourceText, metadata, createdAt, updatedAt)
+     VALUES (?, ?, 'wikilink', 'memory', ?, 1.0, 'wikilink', 'note', NULL, ?, ?)`,
+    [randomUUID(), parentId, neighborId, nowIso, nowIso],
+  );
+});
+
+afterAll(async () => {
+  if (prevHybridFlag === undefined) delete process.env.MEMORY_HYBRID_SEARCH;
+  else process.env.MEMORY_HYBRID_SEARCH = prevHybridFlag;
+  if (prevGraphFlag === undefined) delete process.env.MEMORY_GRAPH_EXPANSION;
+  else process.env.MEMORY_GRAPH_EXPANSION = prevGraphFlag;
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+});
+
+describe("graph route of a neighbour that already matches organically", () => {
+  test("fixture reproduces the review: the uncapped graph route beats the organic one, the capped route does not", async () => {
+    const { candidates } = await searchAndExpand();
+    const now = new Date();
+    const organic = candidates.find((c) => c.id === neighborId)!;
+    const parent = candidates.find((c) => c.id === parentId)!;
+    expect(organic.retrievalSource).toBe("vec");
+    expect(parent.retrievalSource).toBe("vec");
+    expect(candidates.find((c) => c.id === otherId)?.retrievalSource).toBe("vec");
+
+    const graphRoute = { ...organic, similarity: 0.9 * 0.7, retrievalSource: "graph" as const };
+    const organicScore = computeScore(organic, now);
+    const parentScore = computeScore(parent, now);
+    expect(organicScore).toBeCloseTo(0.9, 2);
+    expect(parentScore).toBeCloseTo(0.63, 2);
+    expect(computeScore(graphRoute, now)).toBeGreaterThan(organicScore);
+    expect(Math.min(computeScore(graphRoute, now), parentScore)).toBeLessThan(organicScore);
+  });
+
+  test("a low-quality parent's link does not demote a neighbour's stronger organic match", async () => {
+    const { expanded } = await searchAndExpand();
+    const neighbor = expanded.filter((c) => c.id === neighborId);
+    expect(neighbor).toHaveLength(1);
+    expect(neighbor[0]!.retrievalSource).toBe("vec");
+    expect(neighbor[0]!.graphParentId).toBeUndefined();
+
+    const [top] = rerank(expanded, { limit: 1 });
+    expect(top!.id).toBe(neighborId);
+    expect(top!.retrievalSource).toBe("vec");
+    expect(top!.compositeScore!).toBeCloseTo(0.9, 2);
+  });
+
+  test("the result matches search without graph expansion", async () => {
+    process.env.MEMORY_GRAPH_EXPANSION = "0";
+    try {
+      const { expanded } = await searchAndExpand();
+      const [top] = rerank(expanded, { limit: 1 });
+      expect(top!.id).toBe(neighborId);
+      expect(top!.compositeScore!).toBeCloseTo(0.9, 2);
+    } finally {
+      delete process.env.MEMORY_GRAPH_EXPANSION;
+    }
+  });
+});

package/src/tests/memory-http-recall-gating.test.ts

@@ -5,7 +5,6 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { Readable } from "node:stream";
 import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
 import * as realMemoryModule from "../be/memory";
-import { sourceQuality } from "../be/memory/reranker";
 import { SIMILARITY_THRESHOLD } from "../prompts/memories";
 import type { AgentMemory } from "../types";
 
@@ -111,7 +110,9 @@ mock.module("../be/memory", () => ({
       if (options.queryText === "prompt recall") {
         return [
           candidate(memory, 0.95),
-          candidate(thresholdMemory, SIMILARITY_THRESHOLD / sourceQuality(thresholdMemory.source)),
+          // Relevance exactly at the threshold; the manual-source boost lifts
+          // the composite well above it. The gate must read relevance.
+          candidate(thresholdMemory, SIMILARITY_THRESHOLD),
         ];
       }
       return [candidate(memory, 0.95)];
@@ -281,16 +282,25 @@ describe("memory HTTP recall capture gating", () => {
     ]);
   });
 
-  test("prompt recall excludes memories at the injection threshold", async () => {
+  test("prompt recall gates on relevance, not the boosted composite score", async () => {
     const response = await callMemoryRoute(
       "POST",
       "/api/memory/search",
       ["api", "memory", "search"],
       { query: "prompt recall", intent: "pre-task memory recall", limit: 5 },
-      { "x-memory-consumption": "prompt" },
+      { "x-memory-consumption": "prompt", "x-source-task-id": sourceTaskId },
     );
 
     expect(response.statusCode).toBe(200);
+    const threshold = response.body.results.find((r: any) => r.id === thresholdMemoryId);
+    expect(threshold.similarity).toBeGreaterThan(SIMILARITY_THRESHOLD);
+    expect(threshold.rawSimilarity).toBe(SIMILARITY_THRESHOLD);
+    expect(
+      await getDbClient().get<{ similarity: number; relevance: number }>(
+        "SELECT similarity, relevance FROM memory_retrieval WHERE memoryId = ?",
+        [thresholdMemoryId],
+      ),
+    ).toEqual({ similarity: threshold.similarity, relevance: SIMILARITY_THRESHOLD });
     expect(response.body.results.map((result: any) => result.accessCount)).toEqual([1, 0]);
     expect(
       await getDbClient().get<{ accessCount: number }>(