@desplega.ai/agent-swarm 1.98.1 → 1.99.1

package/src/commands/runner.ts

@@ -1317,6 +1317,7 @@ async function getPausedTasksFromAPI(config: ApiConfig): Promise<
     finishedAt?: string;
     output?: string;
     status?: string;
+    contextKey?: string;
   }>
 > {
   const headers: Record<string, string> = {
@@ -2329,6 +2330,7 @@ async function fetchRelevantMemories(
   agentId: string,
   taskDescription: string,
   taskId?: string,
+  contextKey?: string,
 ): Promise<string | null> {
   try {
     const headers: Record<string, string> = {
@@ -2341,11 +2343,12 @@ async function fetchRelevantMemories(
     // memories they surface against this task's session_logs at completion.
     // Plan: thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-2.md §2
     if (taskId) headers["X-Source-Task-ID"] = taskId;
+    if (contextKey) headers["X-Context-Key"] = contextKey;
 
     const response = await fetch(`${apiUrl}/api/memory/search`, {
       method: "POST",
       headers,
-      body: JSON.stringify({ query: taskDescription, limit: 5 }),
+      body: JSON.stringify({ query: taskDescription, limit: 5, intent: "pre-task memory recall" }),
     });
 
     if (!response.ok) return null;
@@ -2600,6 +2603,7 @@ async function spawnProviderProcess(
     harnessProvider: ProviderName;
     cwd?: string;
     vcsRepo?: string;
+    contextKey?: string;
   },
   logDir: string,
   isYolo: boolean,
@@ -2688,6 +2692,7 @@ async function spawnProviderProcess(
     // Propagate the selected OAuth slot so the adapter refreshes back to the
     // correct pool key. Undefined for non-codex providers and single-cred deploys.
     codexSlot: oauthSelection?.index,
+    contextKey: opts.contextKey,
   };
 
   // Create the long-lived `worker.session` span up front so the provider
@@ -4412,6 +4417,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           agentId,
           task.task,
           task.id,
+          (task as { contextKey?: string }).contextKey,
         );
         if (resumeMemoryContext) {
           resumePrompt += resumeMemoryContext;
@@ -4537,6 +4543,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               harnessProvider: state.harnessProvider,
               cwd: resumeCwd,
               vcsRepo: task.vcsRepo,
+              contextKey: (task as { contextKey?: string }).contextKey,
             },
             logDir,
             isYolo,
@@ -4802,7 +4809,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         if (trigger.type === "task_assigned" || trigger.type === "task_offered") {
           const task =
             trigger.task && typeof trigger.task === "object" && "task" in trigger.task
-              ? (trigger.task as { task: string; id?: string })
+              ? (trigger.task as { task: string; id?: string; contextKey?: string })
               : null;
           if (task?.task) {
             const memoryContext = await fetchRelevantMemories(
@@ -4811,6 +4818,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               agentId,
               task.task,
               task.id,
+              task.contextKey,
             );
             if (memoryContext) {
               triggerPrompt += memoryContext;
@@ -4870,6 +4878,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         // Extract model from task data for per-task model selection
         const taskModel = (trigger.task as { model?: string } | undefined)?.model;
         const taskModelTier = (trigger.task as { modelTier?: string } | undefined)?.modelTier;
+        const taskContextKey = (trigger.task as { contextKey?: string } | undefined)?.contextKey;
 
         // Detect Slack context for conditional prompt sections
         const taskSlackChannelId = (trigger.task as { slackChannelId?: string } | undefined)
@@ -5016,6 +5025,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               harnessProvider: state.harnessProvider,
               cwd: effectiveCwd,
               vcsRepo: taskVcsRepo,
+              contextKey: taskContextKey,
             },
             logDir,
             isYolo,

package/src/e2b/dispatch.ts

@@ -361,6 +361,11 @@ export async function startDetachedProcess(opts: StartDetachedOptions): Promise<
     cwd: opts.cwd ?? "/",
     envs: opts.env,
     background: true,
+    // CRITICAL: the SDK's default `timeoutMs` is 60s and applies to background
+    // commands too — envd kills the whole tracked tree (entrypoint + children)
+    // when it expires, silently stopping the worker runner ~60s after boot.
+    // 0 disables the limit; sandbox lifetime is governed by its own TTL.
+    timeoutMs: 0,
   });
 
   // Early liveness poll: give the entrypoint a moment to fault, then check the

package/src/http/memory.ts

@@ -1,10 +1,11 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import { chunkContent } from "../be/chunking";
-import { getTaskById } from "../be/db";
+import { getDb, getTaskById } from "../be/db";
 import { getEmbeddingProvider, getMemoryStore } from "../be/memory";
 import { CANDIDATE_SET_MULTIPLIER } from "../be/memory/constants";
 import { listEdgesForAgent } from "../be/memory/edges-store";
+import { storeLinks } from "../be/memory/link-resolver";
 import { recordRetrievals } from "../be/memory/raters/retrieval";
 import { applyRating, ExplicitSelfDuplicateError } from "../be/memory/raters/store";
 import {
@@ -37,6 +38,7 @@ const indexMemory = route({
     sourcePath: z.string().optional(),
     tags: z.array(z.string()).optional(),
     persistMemory: z.boolean().optional(),
+    contextKey: z.string().optional(),
   }),
   responses: {
     202: { description: "Content queued for embedding" },
@@ -53,6 +55,13 @@ const searchMemory = route({
   auth: { apiKey: true, agentId: true },
   body: z.object({
     query: z.string().min(1),
+    intent: z
+      .string()
+      .min(1)
+      .optional()
+      .describe(
+        "Why you are searching. Required for agent recall-edge tracking; omit for UI browse/search calls.",
+      ),
     limit: z.number().int().min(1).max(20).default(5),
     scope: z.enum(["agent", "swarm", "all"]).default("all"),
     source: z.enum(["manual", "file_index", "session_summary", "task_completion"]).optional(),
@@ -149,6 +158,15 @@ const getMemoryById = route({
   tags: ["Memory"],
   auth: { apiKey: true, agentId: true },
   params: z.object({ id: z.string().uuid() }),
+  query: z.object({
+    intent: z
+      .string()
+      .min(1)
+      .optional()
+      .describe(
+        "Why you are retrieving this memory. Required for agent recall-edge tracking; omit for UI browse calls.",
+      ),
+  }),
   responses: {
     200: { description: "Memory details" },
     404: { description: "Memory not found" },
@@ -266,8 +284,18 @@ export async function handleMemory(
     const parsed = await indexMemory.parse(req, res, pathSegments, new URLSearchParams());
     if (!parsed) return true;
 
-    const { agentId, content, name, scope, source, sourceTaskId, sourcePath, tags, persistMemory } =
-      parsed.body;
+    const {
+      agentId,
+      content,
+      name,
+      scope,
+      source,
+      sourceTaskId,
+      sourcePath,
+      tags,
+      persistMemory,
+      contextKey,
+    } = parsed.body;
 
     if (source === "session_summary" && sourceTaskId) {
       const sourceTask = getTaskById(sourceTaskId);
@@ -296,6 +324,13 @@ export async function handleMemory(
       store.deleteBySourcePath(sourcePath, agentId);
     }
 
+    // Derive contextKey from body or X-Context-Key header
+    const headerContextKey = req.headers["x-context-key"];
+    const resolvedContextKey =
+      contextKey ??
+      (Array.isArray(headerContextKey) ? headerContextKey[0] : headerContextKey) ??
+      undefined;
+
     // Atomic batch insert — all chunks or none
     const memories = store.storeBatch(
       contentChunks.map((chunk) => ({
@@ -309,9 +344,24 @@ export async function handleMemory(
         chunkIndex: chunk.chunkIndex,
         totalChunks: chunk.totalChunks,
         tags: tags || [],
+        contextKey: resolvedContextKey ?? null,
       })),
     );
 
+    // Resolve and store deterministic links (wikilinks, PR refs, agent-fs paths)
+    if (agentId) {
+      for (const memory of memories) {
+        try {
+          storeLinks(memory.id, agentId, memory.content);
+        } catch (err) {
+          console.error(
+            `[memory] Link resolution failed for ${memory.id}:`,
+            (err as Error).message,
+          );
+        }
+      }
+    }
+
     // Async batch embed (fire and forget)
     (async () => {
       try {
@@ -339,7 +389,7 @@ export async function handleMemory(
     const parsed = await searchMemory.parse(req, res, pathSegments, new URLSearchParams());
     if (!parsed) return true;
 
-    const { query, limit, scope, source } = parsed.body;
+    const { query, intent, limit, scope, source } = parsed.body;
 
     try {
       const provider = getEmbeddingProvider();
@@ -369,12 +419,16 @@ export async function handleMemory(
       const sourceTaskId = Array.isArray(sourceTaskIdHeader)
         ? sourceTaskIdHeader[0]
         : sourceTaskIdHeader;
-      if (sourceTaskId) {
+      const contextKeyHeader = req.headers["x-context-key"];
+      const contextKey = Array.isArray(contextKeyHeader) ? contextKeyHeader[0] : contextKeyHeader;
+      if (sourceTaskId && intent) {
         try {
           recordRetrievals(
             sourceTaskId,
             myAgentId,
             ranked.map((r) => ({ memoryId: r.id, similarity: r.similarity })),
+            undefined,
+            { intent, contextKey, eventType: "search" },
           );
         } catch (err) {
           console.error("[memory-search] recordRetrievals failed:", (err as Error).message);
@@ -620,7 +674,11 @@ export async function handleMemory(
           reasoning: e.reasoning,
           ...(e.referencesSource !== undefined ? { referencesSource: e.referencesSource } : {}),
         }));
-        const result = applyRating(ratingEvents, { taskId });
+        const rateContextKeyHeader = req.headers["x-context-key"];
+        const rateContextKey = Array.isArray(rateContextKeyHeader)
+          ? rateContextKeyHeader[0]
+          : rateContextKeyHeader;
+        const result = applyRating(ratingEvents, { taskId, contextKey: rateContextKey });
         applied += result.applied;
         for (const r of result.rejected) {
           rejected.push({ memoryId: r.event.memoryId, reason: r.reason });
@@ -671,7 +729,8 @@ export async function handleMemory(
   }
 
   if (getMemoryById.match(req.method, pathSegments)) {
-    const parsed = await getMemoryById.parse(req, res, pathSegments, new URLSearchParams());
+    const queryParams = parseQueryParams(req.url || "");
+    const parsed = await getMemoryById.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
 
     const memory = getMemoryStore().get(parsed.params.id);
@@ -680,6 +739,27 @@ export async function handleMemory(
       return true;
     }
 
+    const { intent } = parsed.query;
+    const sourceTaskIdHeader = req.headers["x-source-task-id"];
+    const sourceTaskId = Array.isArray(sourceTaskIdHeader)
+      ? sourceTaskIdHeader[0]
+      : sourceTaskIdHeader;
+    const contextKeyHeader = req.headers["x-context-key"];
+    const contextKey = Array.isArray(contextKeyHeader) ? contextKeyHeader[0] : contextKeyHeader;
+    if (sourceTaskId && myAgentId && intent) {
+      try {
+        recordRetrievals(
+          sourceTaskId,
+          myAgentId,
+          [{ memoryId: memory.id, similarity: 1.0 }],
+          undefined,
+          { intent, contextKey, eventType: "get" },
+        );
+      } catch (err) {
+        console.error("[memory-get] recordRetrievals failed:", (err as Error).message);
+      }
+    }
+
     json(res, { memory });
     return true;
   }
@@ -692,6 +772,23 @@ export async function handleMemory(
 const MEMORY_GC_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
 let memoryGcTimer: ReturnType<typeof setInterval> | null = null;
 
+const SEARCH_RETRIEVAL_TTL_DAYS = 90;
+
+function purgeStaleSearchRetrievals(): number {
+  try {
+    const cutoff = new Date(
+      Date.now() - SEARCH_RETRIEVAL_TTL_DAYS * 24 * 60 * 60 * 1000,
+    ).toISOString();
+    const result = getDb()
+      .prepare("DELETE FROM memory_retrieval WHERE eventType = 'search' AND retrievedAt < ?")
+      .run(cutoff);
+    return result.changes;
+  } catch (err) {
+    console.error("[memory-gc] Search retrieval purge failed:", (err as Error).message);
+    return 0;
+  }
+}
+
 export function startMemoryGc(intervalMs = MEMORY_GC_INTERVAL_MS): void {
   if (memoryGcTimer) return;
 
@@ -701,6 +798,12 @@ export function startMemoryGc(intervalMs = MEMORY_GC_INTERVAL_MS): void {
     if (purged > 0) {
       console.log(`[memory-gc] Initial purge removed ${purged} expired memory row(s)`);
     }
+    const searchPurged = purgeStaleSearchRetrievals();
+    if (searchPurged > 0) {
+      console.log(
+        `[memory-gc] Initial purge removed ${searchPurged} stale search retrieval row(s)`,
+      );
+    }
   } catch (err) {
     console.error("[memory-gc] Initial purge failed:", err);
   }
@@ -711,6 +814,12 @@ export function startMemoryGc(intervalMs = MEMORY_GC_INTERVAL_MS): void {
       if (purged > 0) {
         console.log(`[memory-gc] Periodic purge removed ${purged} expired memory row(s)`);
       }
+      const searchPurged = purgeStaleSearchRetrievals();
+      if (searchPurged > 0) {
+        console.log(
+          `[memory-gc] Periodic purge removed ${searchPurged} stale search retrieval row(s)`,
+        );
+      }
     } catch (err) {
       console.error("[memory-gc] Periodic purge failed:", err);
     }

package/src/providers/claude-adapter.ts

@@ -248,6 +248,7 @@ export function mergeMcpConfig(
   baseConfig: { mcpServers?: Record<string, unknown> } | null,
   installedServers: Record<string, Record<string, unknown>> | null,
   taskId: string,
+  contextKey?: string,
 ): { mcpServers: Record<string, unknown> } {
   const config: { mcpServers: Record<string, unknown> } = {
     mcpServers: { ...(baseConfig?.mcpServers ?? {}) },
@@ -273,6 +274,9 @@ export function mergeMcpConfig(
     const server = config.mcpServers[serverKey] as Record<string, unknown>;
     if (!server.headers) server.headers = {};
     (server.headers as Record<string, string>)["X-Source-Task-Id"] = taskId;
+    if (contextKey) {
+      (server.headers as Record<string, string>)["X-Context-Key"] = contextKey;
+    }
   }
 
   return config;
@@ -291,6 +295,7 @@ export async function createSessionMcpConfig(
   cwd: string,
   taskId: string,
   installedServers?: Record<string, Record<string, unknown>> | null,
+  contextKey?: string,
 ): Promise<string | null> {
   // Collect every .mcp.json from cwd up to filesystem root. Stopping at the first
   // match silently drops the swarm-managed /workspace/.mcp.json when the cloned
@@ -341,7 +346,12 @@ export async function createSessionMcpConfig(
   }
 
   try {
-    const config = mergeMcpConfig({ mcpServers: mergedServers }, installedServers ?? null, taskId);
+    const config = mergeMcpConfig(
+      { mcpServers: mergedServers },
+      installedServers ?? null,
+      taskId,
+      contextKey,
+    );
     const sessionConfigPath = `/tmp/mcp-${taskId}.json`;
     await writeFile(sessionConfigPath, JSON.stringify(config, null, 2));
     return sessionConfigPath;
@@ -950,11 +960,12 @@ export class ClaudeAdapter implements ProviderAdapter {
       );
     }
 
-    // Create per-session MCP config with X-Source-Task-Id header + installed servers (no shared-file race condition)
+    // Create per-session MCP config with X-Source-Task-Id + X-Context-Key headers + installed servers (no shared-file race condition)
     const sessionMcpConfig = await createSessionMcpConfig(
       config.cwd,
       config.taskId,
       installedServers,
+      config.contextKey,
     );
 
     // Stage the system prompt on disk so it can be passed as a file path

package/src/providers/types.ts

@@ -92,6 +92,7 @@ export interface ProviderSessionConfig {
   apiKey: string;
   cwd: string;
   vcsRepo?: string;
+  contextKey?: string;
   /**
    * @deprecated Never set by the runner — native session resume was removed in
    * the 2026-05-28 plan. Adapters log + ignore any stray value. Follow-up

package/src/scripts-runtime/swarm-sdk.ts

@@ -56,7 +56,11 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
     case "memory_get": {
       const memoryId = typeof body.memoryId === "string" ? body.memoryId : undefined;
       if (!memoryId) throw new Error("memory_get requires string `memoryId`");
-      return { method: "GET", path: `/api/memory/${encodeURIComponent(memoryId)}` };
+      const getIntent = typeof body.intent === "string" ? body.intent : "script-sdk";
+      return {
+        method: "GET",
+        path: `/api/memory/${encodeURIComponent(memoryId)}?intent=${encodeURIComponent(getIntent)}`,
+      };
     }
     case "memory_rate": {
       const event = {

package/src/scripts-runtime/types/stdlib.d.ts

@@ -50,11 +50,12 @@ declare module "swarm-sdk" {
     // --- memory ---
     memory_search(args: {
       query: string;
+      intent: string;
       scope?: "all" | "agent" | "swarm";
       limit?: number;
       source?: string;
     }): Promise<unknown>;
-    memory_get(args: { memoryId: string }): Promise<unknown>;
+    memory_get(args: { memoryId: string; intent: string }): Promise<unknown>;
     memory_rate(args: { id: string; useful: boolean; note?: string }): Promise<unknown>;
     // --- tasks ---
     task_list(args?: Record<string, unknown>): Promise<unknown>;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -32,11 +32,12 @@ declare module "swarm-sdk" {
     // --- memory ---
     memory_search(args: {
       query: string;
+      intent: string;
       scope?: "all" | "agent" | "swarm";
       limit?: number;
       source?: string;
     }): Promise<unknown>;
-    memory_get(args: { memoryId: string }): Promise<unknown>;
+    memory_get(args: { memoryId: string; intent: string }): Promise<unknown>;
     memory_rate(args: { id: string; useful: boolean; note?: string }): Promise<unknown>;
     // --- tasks ---
     task_list(args?: Record<string, unknown>): Promise<unknown>;

package/src/tests/internal-ai/complete-structured.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, test } from "bun:test";
 import { Type } from "typebox";
 import { z } from "zod";
-import { completeStructured } from "../../utils/internal-ai/complete-structured.js";
+import {
+  completeStructured,
+  defaultSpawnClaudeCli,
+} from "../../utils/internal-ai/complete-structured.js";
 import type { ResolvedCredential } from "../../utils/internal-ai/credentials.js";
 
 const ResultZodSchema = z.object({
@@ -274,3 +277,33 @@ describe("completeStructured", () => {
     expect(match).toBeDefined();
   });
 });
+
+describe("defaultSpawnClaudeCli", () => {
+  test("sets SKIP_SESSION_SUMMARY=1 in the child env (Stop-hook recursion guard)", async () => {
+    // Without this guard, the spawned `claude -p` summarizer session fires the
+    // same global Stop hook on exit, which spawns another summarizer claude,
+    // recursively — observed OOM-wedging 8GB E2B worker sandboxes.
+    const fakeBinary = `/tmp/fake-claude-${Date.now()}-${Math.random().toString(36).slice(2)}.sh`;
+    await Bun.write(
+      fakeBinary,
+      '#!/usr/bin/env bash\ncat >/dev/null\nprintf \'{"result":"SKIP_SESSION_SUMMARY=%s"}\' "$SKIP_SESSION_SUMMARY"\n',
+    );
+    const savedBinary = process.env.CLAUDE_BINARY;
+    const savedSkip = process.env.SKIP_SESSION_SUMMARY;
+    const savedBridge = process.env.SWARM_USE_CLAUDE_BRIDGE;
+    process.env.CLAUDE_BINARY = `bash ${fakeBinary}`;
+    // Ensure a false-pass via inheritance is impossible.
+    delete process.env.SKIP_SESSION_SUMMARY;
+    delete process.env.SWARM_USE_CLAUDE_BRIDGE;
+    try {
+      const out = await defaultSpawnClaudeCli("prompt", "haiku");
+      expect(out).toBe("SKIP_SESSION_SUMMARY=1");
+    } finally {
+      if (savedBinary === undefined) delete process.env.CLAUDE_BINARY;
+      else process.env.CLAUDE_BINARY = savedBinary;
+      if (savedSkip !== undefined) process.env.SKIP_SESSION_SUMMARY = savedSkip;
+      if (savedBridge !== undefined) process.env.SWARM_USE_CLAUDE_BRIDGE = savedBridge;
+      await Bun.$`rm -f ${fakeBinary}`.quiet();
+    }
+  });
+});

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

@@ -0,0 +1,172 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import { unlink } from "node:fs/promises";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
+import { closeDb, createAgent, getDb, initDb } from "../be/db";
+import type { AgentMemory } from "../types";
+
+const memoryId = randomUUID();
+const agentId = randomUUID();
+const sourceTaskId = randomUUID();
+const TEST_DB_PATH = "./test-memory-http-recall-gating.sqlite";
+
+const memory: AgentMemory = {
+  id: memoryId,
+  agentId,
+  content: "UI browse/search memory fixture",
+  name: "ui-memory-fixture",
+  scope: "agent",
+  source: "manual",
+  sourcePath: null,
+  sourceTaskId: null,
+  chunkIndex: 0,
+  totalChunks: 1,
+  tags: [],
+  contextKey: null,
+  createdAt: new Date("2026-06-14T00:00:00.000Z").toISOString(),
+  updatedAt: new Date("2026-06-14T00:00:00.000Z").toISOString(),
+};
+
+mock.module("../be/memory", () => ({
+  getEmbeddingProvider: () => ({
+    name: "test-embedding",
+    dimensions: 3,
+    embed: async () => new Float32Array([1, 0, 0]),
+    embedBatch: async (texts: string[]) => texts.map(() => new Float32Array([1, 0, 0])),
+  }),
+  getMemoryStore: () => ({
+    get: () => memory,
+    search: () => [
+      {
+        ...memory,
+        similarity: 0.95,
+        rawSimilarity: 0.95,
+        compositeScore: 0.95,
+        accessCount: 0,
+        expiresAt: null,
+        embeddingModel: "test-embedding",
+        alpha: 1,
+        beta: 1,
+      },
+    ],
+  }),
+}));
+
+const { handleMemory } = await import("../http/memory");
+
+type ResponseCapture = {
+  statusCode: number;
+  body: any;
+};
+
+function makeReq(
+  method: string,
+  url: string,
+  body?: unknown,
+  headers: Record<string, string> = {},
+): IncomingMessage {
+  const chunks = body === undefined ? [] : [Buffer.from(JSON.stringify(body))];
+  const req = Readable.from(chunks) as IncomingMessage;
+  req.method = method;
+  req.url = url;
+  req.headers = headers;
+  return req;
+}
+
+function makeRes(capture: ResponseCapture): ServerResponse {
+  return {
+    writeHead(statusCode: number) {
+      capture.statusCode = statusCode;
+      return this;
+    },
+    end(chunk?: unknown) {
+      capture.body = typeof chunk === "string" ? JSON.parse(chunk) : chunk;
+      return this;
+    },
+  } as ServerResponse;
+}
+
+async function callMemoryRoute(
+  method: string,
+  url: string,
+  pathSegments: string[],
+  body?: unknown,
+  headers: Record<string, string> = {},
+): Promise<ResponseCapture> {
+  const capture: ResponseCapture = { statusCode: 0, body: null };
+  const handled = await handleMemory(
+    makeReq(method, url, body, headers),
+    makeRes(capture),
+    pathSegments,
+    agentId,
+  );
+  expect(handled).toBe(true);
+  return capture;
+}
+
+function countRetrievals(): number {
+  return getDb().prepare<{ n: number }, []>("SELECT COUNT(*) AS n FROM memory_retrieval").get()!.n;
+}
+
+beforeAll(async () => {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+
+  initDb(TEST_DB_PATH);
+  createAgent({ id: agentId, name: "HTTP Memory Gating Agent", isLead: false, status: "idle" });
+  const nowIso = new Date().toISOString();
+  getDb()
+    .prepare(
+      `INSERT INTO agent_tasks (id, agentId, task, status, source, createdAt, lastUpdatedAt)
+       VALUES (?, ?, ?, 'in_progress', 'mcp', ?, ?)`,
+    )
+    .run(sourceTaskId, agentId, "HTTP memory recall gating task", nowIso, nowIso);
+});
+
+beforeEach(() => {
+  getDb().run("DELETE FROM memory_retrieval");
+});
+
+afterAll(async () => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+});
+
+describe("memory HTTP recall capture gating", () => {
+  test("POST /api/memory/search accepts UI calls without intent and does not record retrievals", async () => {
+    const response = await callMemoryRoute(
+      "POST",
+      "/api/memory/search",
+      ["api", "memory", "search"],
+      { query: "UI browse/search", limit: 5 },
+      { "x-source-task-id": sourceTaskId, "x-context-key": "task:ui-browse" },
+    );
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.results).toHaveLength(1);
+    expect(response.body.results[0].id).toBe(memoryId);
+    expect(countRetrievals()).toBe(0);
+  });
+
+  test("GET /api/memory/:id accepts UI calls without intent and does not record retrievals", async () => {
+    const response = await callMemoryRoute(
+      "GET",
+      `/api/memory/${memoryId}`,
+      ["api", "memory", memoryId],
+      undefined,
+      { "x-source-task-id": sourceTaskId, "x-context-key": "task:ui-browse" },
+    );
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body.memory.id).toBe(memoryId);
+    expect(countRetrievals()).toBe(0);
+  });
+});