@desplega.ai/agent-swarm 1.91.0 → 1.92.1

package/src/tests/memory-store.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, createAgent, initDb } from "../be/db";
+import { closeDb, createAgent, getDb, initDb } from "../be/db";
+import { serializeEmbedding } from "../be/embedding";
 import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
 
 const TEST_DB_PATH = "./test-memory-store.sqlite";
@@ -10,6 +11,14 @@ describe("SqliteMemoryStore", () => {
   const agentB = "bbbb0000-0000-4000-8000-000000000002";
   let store: SqliteMemoryStore;
 
+  function vector(values: Record<number, number>): Float32Array {
+    const embedding = new Float32Array(512);
+    for (const [index, value] of Object.entries(values)) {
+      embedding[Number(index)] = value;
+    }
+    return embedding;
+  }
+
   beforeAll(async () => {
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
@@ -210,6 +219,95 @@ describe("SqliteMemoryStore", () => {
       const agents = new Set(results.map((r) => r.agentId));
       expect(agents.size).toBeGreaterThanOrEqual(1);
     });
+
+    test("uses sqlite-vec for 512d embeddings with scope-filter parity", () => {
+      for (let i = 0; i < 6; i++) {
+        const otherAgent = store.store({
+          agentId: agentB,
+          scope: "agent",
+          name: `vec-other-agent-exact-${i}`,
+          content: "exact but invisible to agentA",
+          source: "manual",
+        });
+        store.updateEmbedding(otherAgent.id, vector({ 0: 1 }), "test-model");
+      }
+
+      const visible = store.store({
+        agentId: agentA,
+        scope: "agent",
+        name: "vec-agent-visible",
+        content: "visible to agentA",
+        source: "manual",
+      });
+      store.updateEmbedding(visible.id, vector({ 0: 0.8, 1: 0.2 }), "test-model");
+
+      const query = vector({ 0: 1 });
+      const results = store.search(query, agentA, { scope: "agent", limit: 5 });
+
+      expect(results[0]!.id).toBe(visible.id);
+      expect(results.every((r) => r.agentId === agentA && r.scope === "agent")).toBe(true);
+
+      const health = store.getHealth();
+      expect(health.sqliteVec.schema).toContain("distance_metric=cosine");
+      expect(health.counts.memoryVec).toBeGreaterThanOrEqual(2);
+      expect(health.retrievalMode).toBe("vec");
+    });
+  });
+
+  describe("memory_vec population", () => {
+    test("populates existing embeddings on startup and reports health counts", () => {
+      const raw = store.store({
+        agentId: agentA,
+        scope: "agent",
+        name: "raw-existing-embedding",
+        content: "raw existing embedding",
+        source: "manual",
+      });
+      getDb()
+        .prepare("UPDATE agent_memory SET embedding = ?, embeddingModel = ? WHERE id = ?")
+        .run(serializeEmbedding(vector({ 2: 1 })), "test-model", raw.id);
+      getDb().prepare("DELETE FROM memory_vec WHERE memory_id = ?").run(raw.id);
+
+      const freshStore = new SqliteMemoryStore();
+      const health = freshStore.getHealth();
+
+      expect(health.counts.missingFromVec).toBe(0);
+      expect(health.sqliteVec.lastPopulate?.attempted).toBeGreaterThanOrEqual(1);
+      expect(health.sqliteVec.lastPopulate?.failed).toBe(0);
+
+      const resultIds = freshStore
+        .search(vector({ 2: 1 }), agentA, { scope: "agent", limit: 20 })
+        .map((r) => r.id);
+      expect(resultIds).toContain(raw.id);
+    });
+
+    test("rebuilds an old non-cosine memory_vec table from agent_memory", () => {
+      const raw = store.store({
+        agentId: agentA,
+        scope: "agent",
+        name: "stale-schema-embedding",
+        content: "stale schema embedding",
+        source: "manual",
+      });
+      getDb()
+        .prepare("UPDATE agent_memory SET embedding = ?, embeddingModel = ? WHERE id = ?")
+        .run(serializeEmbedding(vector({ 3: 1 })), "test-model", raw.id);
+
+      getDb().run("DROP TABLE memory_vec");
+      getDb().run(`
+        CREATE VIRTUAL TABLE memory_vec USING vec0(
+          memory_id TEXT PRIMARY KEY,
+          embedding float[512]
+        )
+      `);
+
+      const freshStore = new SqliteMemoryStore();
+      const health = freshStore.getHealth();
+
+      expect(health.sqliteVec.schema).toContain("distance_metric=cosine");
+      expect(health.counts.missingFromVec).toBe(0);
+      expect(health.retrievalMode).toBe("vec");
+    });
   });
 
   describe("delete()", () => {
@@ -326,4 +424,126 @@ describe("SqliteMemoryStore", () => {
       expect(filtered.length).toBeGreaterThan(0);
     });
   });
+
+  describe("purgeExpired()", () => {
+    const purgeAgent = "cccc0000-0000-4000-8000-000000000003";
+
+    beforeAll(() => {
+      try {
+        createAgent({ id: purgeAgent, name: "Purge Agent", isLead: false, status: "idle" });
+      } catch {
+        // agent may already exist from a prior run
+      }
+    });
+
+    test("deletes rows past their expiresAt and returns count", () => {
+      const db = getDb();
+
+      // Store a session_summary (3-day TTL) then backdateits expiresAt to the past
+      const mem = store.store({
+        agentId: purgeAgent,
+        scope: "agent",
+        name: "expired session",
+        content: "old session data",
+        source: "session_summary",
+      });
+      db.prepare("UPDATE agent_memory SET expiresAt = datetime('now', '-1 day') WHERE id = ?").run(
+        mem.id,
+      );
+
+      // Store a manual memory (never expires) — should survive
+      const keeper = store.store({
+        agentId: purgeAgent,
+        scope: "agent",
+        name: "keeper",
+        content: "manual content",
+        source: "manual",
+      });
+
+      const purged = store.purgeExpired();
+      expect(purged).toBeGreaterThanOrEqual(1);
+
+      expect(store.get(mem.id)).toBeNull();
+      expect(store.get(keeper.id)).not.toBeNull();
+    });
+
+    test("returns 0 when nothing is expired", () => {
+      const purged = store.purgeExpired();
+      expect(purged).toBe(0);
+    });
+
+    test("also removes corresponding vec rows", () => {
+      const db = getDb();
+      const emb = vector({ 0: 0.9, 100: 0.1 });
+
+      const mem = store.store({
+        agentId: purgeAgent,
+        scope: "agent",
+        name: "vec-purge-test",
+        content: "will be purged",
+        source: "task_completion",
+      });
+      store.updateEmbedding(mem.id, emb, "test-model");
+
+      const vecBefore = db
+        .prepare<{ count: number }, [string]>(
+          "SELECT COUNT(*) as count FROM memory_vec WHERE memory_id = ?",
+        )
+        .get(mem.id);
+
+      // Only check vec cleanup if the row was actually inserted
+      if (vecBefore && vecBefore.count > 0) {
+        db.prepare(
+          "UPDATE agent_memory SET expiresAt = datetime('now', '-1 day') WHERE id = ?",
+        ).run(mem.id);
+
+        store.purgeExpired();
+
+        const vecAfter = db
+          .prepare<{ count: number }, [string]>(
+            "SELECT COUNT(*) as count FROM memory_vec WHERE memory_id = ?",
+          )
+          .get(mem.id);
+        expect(vecAfter?.count ?? 0).toBe(0);
+      }
+    });
+  });
+
+  describe("knn-k cap", () => {
+    test("search does not throw when vec table exceeds 4096 rows", () => {
+      const db = getDb();
+      const emb = vector({ 0: 1.0 });
+      const embBuffer = serializeEmbedding(emb);
+
+      // Check if vec is available — if not, skip (test is meaningful only with vec)
+      const health = store.getHealth();
+      if (health.retrievalMode !== "vec") return;
+
+      // Insert enough rows to exceed 4096 in the vec table
+      const currentCount =
+        db.prepare<{ c: number }, []>("SELECT COUNT(*) as c FROM memory_vec").get()?.c ?? 0;
+      const needed = Math.max(0, 4097 - currentCount);
+
+      for (let i = 0; i < needed; i++) {
+        const id = `knn-test-${i}-${Date.now()}`;
+        db.prepare(
+          "INSERT INTO agent_memory (id, agentId, scope, name, content, source, embedding, chunkIndex, totalChunks, tags, alpha, beta, createdAt, accessedAt) VALUES (?, ?, 'agent', ?, 'knn test', 'manual', ?, 0, 1, '[]', 1, 1, datetime('now'), datetime('now'))",
+        ).run(id, agentA, `knn-${i}`, embBuffer);
+        const vecBuf = new Float32Array(emb);
+        db.prepare("INSERT INTO memory_vec (memory_id, embedding) VALUES (?, ?)").run(
+          id,
+          Buffer.from(vecBuf.buffer),
+        );
+      }
+
+      const vecCount =
+        db.prepare<{ c: number }, []>("SELECT COUNT(*) as c FROM memory_vec").get()?.c ?? 0;
+      expect(vecCount).toBeGreaterThanOrEqual(4097);
+
+      // This should NOT throw — it should clamp k to 4096
+      const results = store.search(emb, agentA, { scope: "agent", limit: 10 });
+      expect(results).toBeDefined();
+      expect(Array.isArray(results)).toBe(true);
+    });
+  });
 });

package/src/tests/pages-http.test.ts

@@ -61,14 +61,13 @@ describe("Pages HTTP API", () => {
     }
   });
 
-  test("POST /api/pages creates a page and returns {id, version}", async () => {
+  test("POST /api/pages creates an authed page by default and returns {id, version}", async () => {
     const res = await fetch(`${baseUrl}/api/pages`, {
       method: "POST",
       headers,
       body: JSON.stringify({
         title: "Hello",
         contentType: "text/html",
-        authMode: "public",
         body: "<h1>hi</h1>",
       }),
     });
@@ -87,6 +86,25 @@ describe("Pages HTTP API", () => {
     expect(page.agentId).toBe(agentId);
     expect(page.slug).toBe("hello"); // auto-slug from title
     expect(page.contentType).toBe("text/html");
+    expect(page.authMode).toBe("authed");
+  });
+
+  test("POST /api/pages can explicitly opt in to public auth", async () => {
+    const res = await fetch(`${baseUrl}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        title: "Public",
+        contentType: "text/html",
+        authMode: "public",
+        body: "<h1>public</h1>",
+      }),
+    });
+
+    expect(res.status).toBe(201);
+    const json = (await res.json()) as { id: string };
+    const got = await fetch(`${baseUrl}/api/pages/${json.id}`, { headers });
+    const page = (await got.json()) as Page;
     expect(page.authMode).toBe("public");
   });
 

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

@@ -5,6 +5,7 @@ import {
   closeDb,
   createPage,
   deletePage,
+  getDb,
   getPage,
   getPageBySlug,
   getPageVersion,
@@ -81,6 +82,31 @@ describe("pages storage CRUD", () => {
     expect(getPageVersions(created.id)).toHaveLength(0);
   });
 
+  test("createPage defaults authMode to authed when omitted", () => {
+    const agentId = makeAgentId();
+    const created = createPage({
+      agentId,
+      slug: "default-auth",
+      title: "Default Auth",
+      contentType: "text/html",
+      body: "<h1>default</h1>",
+    });
+
+    expect(created.authMode).toBe("authed");
+  });
+
+  test("pages table defaults authMode to authed when omitted", () => {
+    const agentId = makeAgentId();
+    const row = getDb()
+      .prepare<{ authMode: string }, [string, string, string, string, string]>(
+        `INSERT INTO pages (agentId, slug, title, contentType, body)
+         VALUES (?, ?, ?, ?, ?) RETURNING authMode`,
+      )
+      .get(agentId, "sql-default-auth", "SQL Default Auth", "text/html", "<h1>default</h1>");
+
+    expect(row?.authMode).toBe("authed");
+  });
+
   test("snapshotPage captures PRE-update content; post-update lives on parent", () => {
     const agentId = makeAgentId();
     const page = createPage({

package/src/tests/prompt-template-session.test.ts

@@ -54,7 +54,7 @@ describe("Session templates — registration", () => {
     await ensureTemplatesRegistered();
   });
 
-  test("all 14 system templates are registered", () => {
+  test("all 15 system templates are registered", () => {
     const systemTemplates = [
       "system.agent.role",
       "system.agent.register",
@@ -66,6 +66,7 @@ describe("Session templates — registration", () => {
       "system.agent.agent_fs",
       "system.agent.self_awareness",
       "system.agent.context_mode",
+      "system.agent.seed_scripts",
 
       "system.agent.system",
       "system.agent.services",
@@ -90,12 +91,12 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 20 session/system templates registered", () => {
+  test("total of 21 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    // 20 = the original 19 + `system.session.worker.pi` (a pi-specific worker
-    // composite that omits the context_mode block — see session-templates.ts).
-    expect(sessionSystem.length).toBe(20);
+    // 21 = the original 19 + `system.session.worker.pi` + `system.agent.seed_scripts`.
+    // The pi composite omits script nudges because pi workers do not have MCP.
+    expect(sessionSystem.length).toBe(21);
   });
 });
 
@@ -187,6 +188,15 @@ describe("Session templates — individual resolution", () => {
     expect(result.text).toContain("batch_execute");
   });
 
+  test("system.agent.seed_scripts points agents at task-start scripts", () => {
+    const result = resolveTemplate("system.agent.seed_scripts", {});
+    expect(result.text).toContain("Pre-built Seed Scripts");
+    expect(result.text).toContain("task-context-gathering");
+    expect(result.text).toContain("smart-recall");
+    expect(result.text).toContain("script-search");
+    expect(result.text).not.toContain("compound-insights");
+  });
+
   // system.agent.guidelines was removed — its content was redundant with worker/lead templates
 
   test("system.agent.system contains package info", () => {
@@ -240,6 +250,7 @@ describe("Session templates — composite resolution", () => {
 
     // Contains context_mode
     expect(result.text).toContain("Context Window Management");
+    expect(result.text).toContain("Pre-built Seed Scripts");
 
     // Guidelines template was removed (redundant with lead/worker templates)
 
@@ -275,6 +286,7 @@ describe("Session templates — composite resolution", () => {
 
     // Contains context_mode
     expect(result.text).toContain("Context Window Management");
+    expect(result.text).toContain("Pre-built Seed Scripts");
 
     // Guidelines template was removed (redundant with lead/worker templates)
 
@@ -309,6 +321,8 @@ describe("Session templates — composite resolution", () => {
     expect(workerResult.text).toContain("join-swarm");
     expect(leadResult.text).toContain("How You Are Built");
     expect(workerResult.text).toContain("How You Are Built");
+    expect(leadResult.text).toContain("Pre-built Seed Scripts");
+    expect(workerResult.text).toContain("Pre-built Seed Scripts");
 
     // Lead has lead content, not worker
     expect(leadResult.text).toContain("CRITICAL: You are a coordinator");
@@ -343,6 +357,7 @@ describe("Session templates — getBasePrompt integration", () => {
     expect(result).toContain("join-swarm");
     expect(result).toContain("store-progress");
     expect(result).toContain("How You Are Built");
+    expect(result).toContain("Pre-built Seed Scripts");
     expect(result).toContain("System packages available");
 
     // Conditional sections (services included by default)
@@ -365,8 +380,22 @@ describe("Session templates — getBasePrompt integration", () => {
     expect(result).toContain("your role is: lead");
     expect(result).toContain("integration-test-lead");
     expect(result).toContain("CRITICAL: You are a coordinator");
+    expect(result).toContain("Pre-built Seed Scripts");
 
     // Should NOT have worker content
     expect(result).not.toContain("task-action");
   });
+
+  test("getBasePrompt excludes seed_scripts for pi worker", async () => {
+    const { getBasePrompt } = await import("../prompts/base-prompt");
+    const result = await getBasePrompt({
+      role: "worker",
+      agentId: "integration-test-pi",
+      swarmUrl: "swarm.test.com",
+      provider: "pi",
+    });
+
+    expect(result).not.toContain("Pre-built Seed Scripts");
+    expect(result).not.toContain("task-context-gathering");
+  });
 });