@desplega.ai/agent-swarm 1.98.0 → 1.99.0

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/pricing-refresh.test.ts

@@ -0,0 +1,156 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getActivePricingRow, getDb, getLogsByEventType, initDb } from "../be/db";
+import type { ModelsDevCache } from "../be/modelsdev-cache";
+import { refreshPricingFromModelsDev } from "../be/pricing-refresh";
+
+const TEST_DB_PATH = "./test-pricing-refresh.sqlite";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function responseFor(cache: ModelsDevCache, etag = '"test-etag"'): Response {
+  return new Response(JSON.stringify(cache), {
+    status: 200,
+    headers: { "content-type": "application/json", etag },
+  });
+}
+
+function openAiCache(input: number, output: number): ModelsDevCache {
+  return {
+    openai: {
+      models: {
+        "gpt-refresh-test": {
+          cost: { input, output },
+        },
+      },
+    },
+  };
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+afterEach(() => {
+  const db = getDb();
+  db.prepare("DELETE FROM pricing").run();
+  db.prepare("DELETE FROM agent_log WHERE eventType LIKE 'pricing.refresh%'").run();
+});
+
+describe("models.dev runtime pricing refresh", () => {
+  test("inserts a new effective row when upstream price changes and no-ops identical prices", async () => {
+    const db = getDb();
+    db.prepare(
+      `INSERT INTO pricing
+       (provider, model, token_class, effective_from, price_per_million_usd, createdAt, lastUpdatedAt)
+       VALUES ('codex', 'gpt-refresh-test', 'input', 0, 1, 0, 0)`,
+    ).run();
+
+    const first = await refreshPricingFromModelsDev({
+      now: 1_000,
+      fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-1"'),
+    });
+    expect(first.status).toBe("refreshed");
+    expect(first.candidateRows).toBe(4);
+    expect(first.inserted).toBe(4);
+    expect(first.unchanged).toBe(0);
+
+    const activeChanged = getActivePricingRow("codex", "gpt-refresh-test", "input", 1_000);
+    expect(activeChanged?.effectiveFrom).toBe(1_000);
+    expect(activeChanged?.pricePerMillionUsd).toBe(2);
+
+    const second = await refreshPricingFromModelsDev({
+      now: 2_000,
+      fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-2"'),
+    });
+    expect(second.inserted).toBe(0);
+    expect(second.unchanged).toBe(4);
+
+    const rows = db
+      .prepare<{ effective_from: number }, []>(
+        `SELECT effective_from FROM pricing
+         WHERE provider = 'codex'
+           AND model = 'gpt-refresh-test'
+           AND token_class = 'input'
+         ORDER BY effective_from`,
+      )
+      .all();
+    expect(rows.map((row) => row.effective_from)).toEqual([0, 1_000]);
+  });
+
+  test("sends If-None-Match and short-circuits on HTTP 304", async () => {
+    await refreshPricingFromModelsDev({
+      now: 1_000,
+      fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-304"'),
+    });
+
+    let ifNoneMatch: string | null = null;
+    const result = await refreshPricingFromModelsDev({
+      now: 2_000,
+      fetchImpl: async (_input, init) => {
+        const headers = new Headers(init?.headers);
+        ifNoneMatch = headers.get("if-none-match");
+        return new Response(null, { status: 304 });
+      },
+    });
+
+    expect(ifNoneMatch).toBe('"etag-304"');
+    expect(result.status).toBe("not_modified");
+    expect(result.inserted).toBe(0);
+  });
+
+  test("prunes pricing history to the latest two effective rows per triple", async () => {
+    const db = getDb();
+    const insert = db.prepare(
+      `INSERT INTO pricing
+       (provider, model, token_class, effective_from, price_per_million_usd, createdAt, lastUpdatedAt)
+       VALUES ('codex', 'gpt-refresh-test', 'input', ?, ?, 0, 0)`,
+    );
+    insert.run(1_000, 1);
+    insert.run(2_000, 2);
+    insert.run(3_000, 3);
+
+    const result = await refreshPricingFromModelsDev({
+      now: 4_000,
+      fetchImpl: async () => responseFor(openAiCache(3, 8), '"etag-prune"'),
+    });
+
+    expect(result.pruned).toBe(1);
+    const rows = db
+      .prepare<{ effective_from: number }, []>(
+        `SELECT effective_from FROM pricing
+         WHERE provider = 'codex'
+           AND model = 'gpt-refresh-test'
+           AND token_class = 'input'
+         ORDER BY effective_from`,
+      )
+      .all();
+    expect(rows.map((row) => row.effective_from)).toEqual([2_000, 3_000]);
+  });
+
+  test("writes scrubbed audit log entries for successful refreshes", async () => {
+    await refreshPricingFromModelsDev({
+      now: 1_000,
+      fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-log"'),
+    });
+
+    const logs = getLogsByEventType("pricing.refresh");
+    expect(logs).toHaveLength(1);
+    expect(logs[0]?.newValue).toContain("inserted=4");
+    expect(logs[0]?.metadata).toContain('"etag":"\\"etag-log\\""');
+  });
+});

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

@@ -3,9 +3,12 @@ import {
   buildIdentityPayload,
   CLAUDE_MD_PATH,
   collectProfilePayloads,
+  contentSha256,
   extractSetupScriptContent,
   type FileReader,
+  IDENTITY_BASELINES_PATH,
   IDENTITY_MD_PATH,
+  type IdentityBaselines,
   postProfileUpdate,
   resolveClaudeMdPath,
   SETUP_SCRIPT_PATH,
@@ -280,3 +283,186 @@ describe("syncProfileFilesToServer (orchestration is non-fatal)", () => {
     }
   });
 });
+
+// ── Baseline comparison tests ─────────────────────────────────────────────
+// These test the fix for Lead's update-profile edits getting clobbered by
+// the worker's session-end sync. When a file's content hash matches the
+// baseline recorded at session start, it means the agent didn't modify it,
+// so session_sync skips it to preserve any DB-side edits made by Lead.
+
+describe("buildIdentityPayload (baseline comparison)", () => {
+  const baselines: IdentityBaselines = {
+    soulMd: contentSha256(LONG),
+    identityMd: contentSha256(LONG),
+    toolsMd: contentSha256("original tools"),
+    heartbeatMd: contentSha256("original heartbeat"),
+  };
+
+  test("skips files whose hash matches the baseline (unchanged during session)", () => {
+    const payload = buildIdentityPayload(
+      {
+        soulMd: LONG,
+        identityMd: LONG,
+        toolsMd: "original tools",
+        heartbeatMd: "original heartbeat",
+      },
+      baselines,
+    );
+    expect(payload).toEqual({});
+  });
+
+  test("includes files whose content differs from the baseline (modified during session)", () => {
+    const modifiedSoul = `${LONG} — agent added this`;
+    const payload = buildIdentityPayload(
+      {
+        soulMd: modifiedSoul,
+        identityMd: LONG, // unchanged
+        toolsMd: "modified tools",
+        heartbeatMd: "original heartbeat", // unchanged
+      },
+      baselines,
+    );
+    expect(payload.soulMd).toBe(modifiedSoul);
+    expect(payload.identityMd).toBeUndefined();
+    expect(payload.toolsMd).toBe("modified tools");
+    expect(payload.heartbeatMd).toBeUndefined();
+  });
+
+  test("without baselines (null), all files sync as before (backwards compat)", () => {
+    const payload = buildIdentityPayload(
+      { soulMd: LONG, identityMd: LONG, toolsMd: "tools" },
+      null,
+    );
+    expect(payload.soulMd).toBe(LONG);
+    expect(payload.identityMd).toBe(LONG);
+    expect(payload.toolsMd).toBe("tools");
+  });
+
+  test("without baselines (undefined), all files sync as before (backwards compat)", () => {
+    const payload = buildIdentityPayload({ soulMd: LONG, identityMd: LONG }, undefined);
+    expect(payload.soulMd).toBe(LONG);
+    expect(payload.identityMd).toBe(LONG);
+  });
+
+  test("a field missing from baselines is still synced (partial baseline)", () => {
+    const partial: IdentityBaselines = { soulMd: contentSha256(LONG) };
+    const payload = buildIdentityPayload({ soulMd: LONG, identityMd: LONG }, partial);
+    expect(payload.soulMd).toBeUndefined(); // matches baseline → skipped
+    expect(payload.identityMd).toBe(LONG); // no baseline → synced
+  });
+});
+
+describe("collectProfilePayloads (baseline integration)", () => {
+  const reader = (files: Record<string, string>): FileReader => {
+    return async (path: string) => files[path];
+  };
+
+  test("session_sync skips unchanged identity files when baselines exist", async () => {
+    const identityContent = LONG;
+    const toolsContent = "original tools";
+    const modifiedToolsContent = "modified tools";
+
+    const baselines: IdentityBaselines = {
+      soulMd: contentSha256(identityContent),
+      identityMd: contentSha256(identityContent),
+      toolsMd: contentSha256(toolsContent),
+    };
+
+    const files = reader({
+      [SOUL_MD_PATH]: identityContent,
+      [IDENTITY_MD_PATH]: identityContent,
+      [TOOLS_MD_PATH]: modifiedToolsContent,
+      [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+    });
+
+    const payloads = await collectProfilePayloads(["identity"], "session_sync", files);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]?.body.toolsMd).toBe(modifiedToolsContent);
+    expect(payloads[0]?.body.soulMd).toBeUndefined();
+    expect(payloads[0]?.body.identityMd).toBeUndefined();
+  });
+
+  test("self_edit bypasses baselines (agent explicitly changed the file)", async () => {
+    const identityContent = LONG;
+
+    const files = reader({
+      [SOUL_MD_PATH]: identityContent,
+      [IDENTITY_MD_PATH]: identityContent,
+      [TOOLS_MD_PATH]: "tools",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify({
+        soulMd: contentSha256(identityContent),
+        identityMd: contentSha256(identityContent),
+        toolsMd: contentSha256("tools"),
+      }),
+    });
+
+    const payloads = await collectProfilePayloads(["identity"], "self_edit", files);
+    expect(payloads).toHaveLength(1);
+    // self_edit should include ALL files regardless of baselines
+    expect(payloads[0]?.body.soulMd).toBe(identityContent);
+    expect(payloads[0]?.body.identityMd).toBe(identityContent);
+    expect(payloads[0]?.body.toolsMd).toBe("tools");
+  });
+
+  test("session_sync skips unchanged CLAUDE.md when baseline matches", async () => {
+    const claudeContent = "original claude md";
+    const baselines: IdentityBaselines = { claudeMd: contentSha256(claudeContent) };
+
+    const files = reader({
+      [CLAUDE_MD_PATH]: claudeContent,
+      [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+    });
+
+    const payloads = await collectProfilePayloads(["claude"], "session_sync", files);
+    expect(payloads).toEqual([]);
+  });
+
+  test("session_sync syncs modified CLAUDE.md even when baselines exist", async () => {
+    const baselines: IdentityBaselines = { claudeMd: contentSha256("original") };
+
+    const files = reader({
+      [CLAUDE_MD_PATH]: "modified claude md",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+    });
+
+    const payloads = await collectProfilePayloads(["claude"], "session_sync", files);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]?.body.claudeMd).toBe("modified claude md");
+  });
+
+  test("session_sync proceeds normally when baselines file is missing", async () => {
+    const files = reader({
+      [TOOLS_MD_PATH]: "tools content",
+      // No IDENTITY_BASELINES_PATH → baselines will be null → no skipping
+    });
+
+    const payloads = await collectProfilePayloads(["identity"], "session_sync", files);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]?.body.toolsMd).toBe("tools content");
+  });
+
+  test("all identity files unchanged → no identity payload at all", async () => {
+    const baselines: IdentityBaselines = {
+      soulMd: contentSha256(LONG),
+      identityMd: contentSha256(LONG),
+      toolsMd: contentSha256("tools"),
+      heartbeatMd: contentSha256("heartbeat"),
+    };
+
+    const files = reader({
+      [SOUL_MD_PATH]: LONG,
+      [IDENTITY_MD_PATH]: LONG,
+      [TOOLS_MD_PATH]: "tools",
+      "/workspace/HEARTBEAT.md": "heartbeat",
+      [IDENTITY_BASELINES_PATH]: JSON.stringify(baselines),
+    });
+
+    const payloads = await collectProfilePayloads(
+      ["identity", "claude", "setup"],
+      "session_sync",
+      files,
+    );
+    // No identity payload (all skipped), no claude or setup (files missing)
+    expect(payloads).toEqual([]);
+  });
+});

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" };