@desplega.ai/agent-swarm 1.98.1 → 1.99.0

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

package/src/tests/memory-link-resolver.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import { resolveLinks } from "../be/memory/link-resolver";
+
+describe("resolveLinks", () => {
+  test("extracts wikilinks from content", () => {
+    const links = resolveLinks("See [[auth-fix-pattern]] and [[pr585-codex-binary]] for context.");
+    expect(links).toHaveLength(2);
+    expect(links[0]).toMatchObject({
+      linkType: "wikilink",
+      targetKind: "memory",
+      targetId: "auth-fix-pattern",
+      resolver: "wikilink",
+    });
+    expect(links[1]).toMatchObject({
+      linkType: "wikilink",
+      targetKind: "memory",
+      targetId: "pr585-codex-binary",
+      resolver: "wikilink",
+    });
+  });
+
+  test("extracts PR references with hash notation", () => {
+    const links = resolveLinks("Fixed in #696 and PR #470.");
+    const prLinks = links.filter((l) => l.linkType === "pr");
+    expect(prLinks.length).toBeGreaterThanOrEqual(2);
+    const ids = prLinks.map((l) => l.targetId);
+    expect(ids).toContain("pr:696");
+    expect(ids).toContain("pr:470");
+  });
+
+  test("extracts full GitHub PR URLs", () => {
+    const links = resolveLinks(
+      "See https://github.com/desplega-ai/agent-swarm/pull/763 for the fix.",
+    );
+    const prLinks = links.filter((l) => l.linkType === "pr");
+    expect(prLinks).toHaveLength(1);
+    expect(prLinks[0]).toMatchObject({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: "github:desplega-ai/agent-swarm#763",
+      resolver: "pr-url",
+    });
+  });
+
+  test("extracts agent-fs paths", () => {
+    const links = resolveLinks(
+      "Plan at live.agent-fs.dev/file/~/648a5f3c-35c8-4f11-8673-b89de52cd6bd/2faf73ba-4eee-4472-8b3b-359c4ed6bfbb/thoughts/plan.md",
+    );
+    const fsLinks = links.filter((l) => l.linkType === "agent-fs-file");
+    expect(fsLinks).toHaveLength(1);
+    expect(fsLinks[0]!.targetKind).toBe("agent-fs-file");
+    expect(fsLinks[0]!.resolver).toBe("agent-fs-path");
+  });
+
+  test("extracts agent-ui page links", () => {
+    const links = resolveLinks(
+      "See app.agent-swarm.dev/pages/abc12345-1234-1234-1234-123456789abc",
+    );
+    const uiLinks = links.filter((l) => l.linkType === "agent-ui");
+    expect(uiLinks).toHaveLength(1);
+    expect(uiLinks[0]).toMatchObject({
+      targetKind: "agent-ui",
+      targetId: "page:abc12345-1234-1234-1234-123456789abc",
+      resolver: "agent-ui-page",
+    });
+  });
+
+  test("deduplicates PR references", () => {
+    const links = resolveLinks("PR #696, see also PR #696 again, and #696 once more.");
+    const prLinks = links.filter((l) => l.linkType === "pr");
+    const ids696 = prLinks.filter((l) => l.targetId === "pr:696");
+    expect(ids696).toHaveLength(1);
+  });
+
+  test("returns empty array for content without links", () => {
+    const links = resolveLinks("This is plain text with no links or references.");
+    expect(links).toHaveLength(0);
+  });
+
+  test("handles mixed content with multiple link types", () => {
+    const content = `
+      See [[memory-search-fix]] for context.
+      PR #696 fixed the embedding issue.
+      Plan: live.agent-fs.dev/file/~/648a5f3c-35c8-4f11-8673-b89de52cd6bd/2faf73ba/thoughts/plan.md
+    `;
+    const links = resolveLinks(content);
+    const types = new Set(links.map((l) => l.linkType));
+    expect(types.has("wikilink")).toBe(true);
+    expect(types.has("pr")).toBe(true);
+    expect(types.has("agent-fs-file")).toBe(true);
+  });
+});

package/src/tests/opencode-adapter.test.ts

@@ -682,12 +682,15 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
 
     expect(lastCreateOpencodeConfig).toBeDefined();
     const opts = lastCreateOpencodeConfig as {
+      timeout?: number;
       config?: {
         model?: string;
         mcp?: Record<string, unknown>;
         permission?: Record<string, string>;
       };
     };
+    // Server-start timeout must override the SDK's 5s default (E2B cold-start flake)
+    expect(opts.timeout).toBe(30_000);
     expect(opts.config?.model).toBe("claude-sonnet-4-6");
     expect(opts.config?.mcp?.swarm).toBeDefined();
     const swarm = opts.config?.mcp?.swarm as {

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

@@ -453,7 +453,7 @@ describe("collectProfilePayloads (baseline integration)", () => {
       [SOUL_MD_PATH]: LONG,
       [IDENTITY_MD_PATH]: LONG,
       [TOOLS_MD_PATH]: "tools",
-      ["/workspace/HEARTBEAT.md"]: "heartbeat",
+      "/workspace/HEARTBEAT.md": "heartbeat",
       [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
     });