@desplega.ai/agent-swarm 1.98.1 → 1.99.1

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

package/src/tests/scripts-mcp-e2e.test.ts

@@ -330,7 +330,7 @@ describe("script_ MCP HTTP proxy tools", () => {
     const tools = buildToolServer();
     const source = `
       import type { ScriptContext, SwarmSdk } from "swarm-sdk";
-      const compileOnly = (swarm: SwarmSdk) => swarm.memory_search({ query: "foo" });
+      const compileOnly = (swarm: SwarmSdk) => swarm.memory_search({ query: "foo", intent: "test" });
       export default async (_args: unknown, ctx: ScriptContext) => {
         void compileOnly;
         return { hasMemorySearch: typeof ctx.swarm.memory_search === "function" };

package/src/tools/memory-get.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getMemoryStore } from "@/be/memory";
+import { recordRetrievals } from "@/be/memory/raters/retrieval";
 import { createToolRegistrar } from "@/tools/utils";
 import type { AgentMemorySource } from "@/types";
 import { AgentMemorySchema } from "@/types";
@@ -18,6 +19,12 @@ export const registerMemoryGetTool = (server: McpServer) => {
 
       inputSchema: z.object({
         memoryId: z.uuid().describe("The ID of the memory to retrieve."),
+        intent: z
+          .string()
+          .min(1)
+          .describe(
+            "Why you are retrieving this memory. Required. E.g. 'need full details of the auth fix pattern'.",
+          ),
       }),
       outputSchema: z.object({
         yourAgentId: z.string().uuid().optional(),
@@ -27,7 +34,7 @@ export const registerMemoryGetTool = (server: McpServer) => {
         rateHint: z.string().optional(),
       }),
     },
-    async ({ memoryId }, requestInfo, _meta) => {
+    async ({ memoryId, intent }, requestInfo, _meta) => {
       const memory = getMemoryStore().get(memoryId);
 
       if (!memory) {
@@ -41,6 +48,20 @@ export const registerMemoryGetTool = (server: McpServer) => {
         };
       }
 
+      if (requestInfo.sourceTaskId && requestInfo.agentId) {
+        try {
+          recordRetrievals(
+            requestInfo.sourceTaskId,
+            requestInfo.agentId,
+            [{ memoryId: memory.id, similarity: 1.0 }],
+            requestInfo.sessionId,
+            { intent, contextKey: requestInfo.contextKey, eventType: "get" },
+          );
+        } catch (err) {
+          console.error("[memory-get] recordRetrievals failed:", (err as Error).message);
+        }
+      }
+
       const inTaskContext = !!requestInfo.sourceTaskId;
       const rateHint =
         inTaskContext && NUDGE_ELIGIBLE_SOURCES.has(memory.source as AgentMemorySource)

package/src/tools/memory-search.ts

@@ -26,6 +26,12 @@ export const registerMemorySearchTool = (server: McpServer) => {
 
       inputSchema: z.object({
         query: z.string().min(1).describe("Natural language search query."),
+        intent: z
+          .string()
+          .min(1)
+          .describe(
+            "Why you are searching for this memory. Required. E.g. 'looking for auth pattern to fix login bug'.",
+          ),
         scope: z
           .enum(["all", "agent", "swarm"])
           .default("all")
@@ -56,7 +62,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
         _ratingNudge: z.string().optional(),
       }),
     },
-    async ({ query, scope, limit, source }, requestInfo, _meta) => {
+    async ({ query, intent, scope, limit, source }, requestInfo, _meta) => {
       if (!requestInfo.agentId) {
         return {
           content: [{ type: "text", text: "Agent ID required for memory search." }],
@@ -97,6 +103,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
               requestInfo.agentId,
               ranked.map((r) => ({ memoryId: r.id, similarity: r.similarity })),
               requestInfo.sessionId,
+              { intent, contextKey: requestInfo.contextKey, eventType: "search" },
             );
           } catch (err) {
             console.error("[memory-search] recordRetrievals failed:", (err as Error).message);

package/src/tools/utils.ts

@@ -21,11 +21,13 @@ export type RequestInfo = {
   sessionId: string | undefined;
   agentId: string | undefined;
   sourceTaskId: string | undefined;
+  contextKey: string | undefined;
 };
 
 export const getRequestInfo = (req: Meta): RequestInfo => {
   const agentIdHeader = req.requestInfo?.headers?.["x-agent-id"];
   const sourceTaskIdHeader = req.requestInfo?.headers?.["x-source-task-id"];
+  const contextKeyHeader = req.requestInfo?.headers?.["x-context-key"];
 
   let agentId: string | undefined;
   if (Array.isArray(agentIdHeader)) {
@@ -41,10 +43,18 @@ export const getRequestInfo = (req: Meta): RequestInfo => {
     sourceTaskId = sourceTaskIdHeader;
   }
 
+  let contextKey: string | undefined;
+  if (Array.isArray(contextKeyHeader)) {
+    contextKey = contextKeyHeader?.[0];
+  } else if (typeof contextKeyHeader === "string") {
+    contextKey = contextKeyHeader;
+  }
+
   return {
     sessionId: req.sessionId || undefined,
     agentId,
     sourceTaskId,
+    contextKey,
   };
 };
 

package/src/utils/internal-ai/complete-structured.ts

@@ -78,7 +78,8 @@ function stripJsonFences(raw: string): string {
   return fenced?.[1] ? fenced[1].trim() : trimmed;
 }
 
-async function defaultSpawnClaudeCli(
+/** Exported for tests only — production callers go through `completeStructured`. */
+export async function defaultSpawnClaudeCli(
   prompt: string,
   model: string,
   signal?: AbortSignal,
@@ -105,6 +106,14 @@ async function defaultSpawnClaudeCli(
   if (!env.CLAUDE_CODE_OAUTH_TOKEN && env.AGENT_SWARM_CLAUDE_OAUTH_TOKEN) {
     env.CLAUDE_CODE_OAUTH_TOKEN = env.AGENT_SWARM_CLAUDE_OAUTH_TOKEN;
   }
+  // Recursion guard: this shellout is itself a full claude session — on exit it
+  // fires the same global Stop hook, whose session-summary path would spawn
+  // another `claude -p`, recursively (each level holds a ~0.5-1GB node process;
+  // observed OOM-wedging 8GB E2B worker sandboxes within ~90s, leaving 10+
+  // near-identical summarizer transcripts in ~/.claude/projects). The hook's
+  // `runStopHookSessionSummary` honors this flag — same convention as the
+  // `claude -p` shellout in `src/be/memory/raters/llm-client.ts`.
+  env.SKIP_SESSION_SUMMARY = "1";
   const proc = Bun.spawn({
     cmd,
     env,

package/tsconfig.json

@@ -34,6 +34,7 @@
     "noPropertyAccessFromIndexSignature": false
   },
   "exclude": [
+    "evals",
     "ui",
     "templates-ui",
     "node_modules",