@pentatonic-ai/ai-agent-sdk 0.5.5 → 0.5.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pentatonic-ai/ai-agent-sdk",
-  "version": "0.5.5",
-  "description": "TES SDK — LLM observability and lifecycle tracking via Pentatonic Thing Event System. Track token usage, tool calls, and conversations. Manage things through event-sourced lifecycle stages with AI enrichment and vector search.",
+  "version": "0.5.7",
+  "description": "TES SDK \u2014 LLM observability and lifecycle tracking via Pentatonic Thing Event System. Track token usage, tool calls, and conversations. Manage things through event-sourced lifecycle stages with AI enrichment and vector search.",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -13,7 +13,8 @@
     "./memory": "./packages/memory/src/index.js",
     "./memory/server": "./packages/memory/src/server.js",
     "./memory/openclaw": "./packages/memory/src/openclaw/index.js",
-    "./doctor": "./packages/doctor/src/index.js"
+    "./doctor": "./packages/doctor/src/index.js",
+    "./memory/hosted": "./packages/memory/src/hosted.js"
   },
   "bin": {
     "ai-agent-sdk": "./bin/cli.js"
@@ -54,7 +55,9 @@
     "model-context-protocol"
   ],
   "openclaw": {
-    "extensions": ["./packages/memory/src/openclaw/index.js"],
+    "extensions": [
+      "./packages/memory/src/openclaw/index.js"
+    ],
     "hooks": {}
   },
   "license": "MIT",

package/packages/memory/openclaw-plugin/__tests__/sanitizer.test.js

@@ -0,0 +1,135 @@
+/**
+ * OpenClaw plugin — memory-content sanitization tests.
+ *
+ * Verifies the sanitizer is actually applied at the two format
+ * surfaces: the context-engine `assemble` output and the
+ * `pentatonic_memory_search` tool result.
+ */
+
+import plugin from "../index.js";
+
+const realFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+function mockSearchReturns(results) {
+  globalThis.fetch = async (_url, init) => {
+    const body = init?.body ? JSON.parse(init.body) : null;
+    const query = body?.query || "";
+    if (query.includes("semanticSearchMemories")) {
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ data: { semanticSearchMemories: results } }),
+      };
+    }
+    return {
+      ok: true,
+      status: 200,
+      json: async () => ({ data: {} }),
+    };
+  };
+}
+
+function makeEngine(extraConfig = {}) {
+  let factory;
+  plugin.register({
+    pluginConfig: {
+      tes_endpoint: "https://x.test",
+      tes_client_id: "c",
+      tes_api_key: "tes_c_xyz",
+      ...extraConfig,
+    },
+    registerTool: () => {},
+    registerContextEngine: (_name, fn) => {
+      factory = fn;
+    },
+  });
+  if (!factory) throw new Error("no engine registered");
+  return factory();
+}
+
+describe("openclaw-plugin — assemble applies memory sanitizer", () => {
+  it("strips TES dashboard noise before injecting into systemPromptAddition", async () => {
+    const noisy = [
+      "[2026-04-21T11:47:04.826Z] I have a subaru and hyundai.",
+      "anonymous",
+      "ml_phil-h-claude_episodic",
+      "100% match",
+      "Confidence: 100%",
+      "Accessed: 2x",
+      "<1h ago",
+      "Decay: 0.05",
+    ].join("\n");
+    mockSearchReturns([{ id: "m1", content: noisy, similarity: 0.9 }]);
+    const engine = makeEngine();
+
+    const result = await engine.assemble({
+      sessionId: "s",
+      messages: [{ role: "user", content: "what car do I drive?" }],
+    });
+
+    const addition = result.systemPromptAddition || "";
+    expect(addition).toMatch(/I have a subaru and hyundai/);
+    expect(addition).not.toMatch(/ml_phil-h-claude_episodic/);
+    expect(addition).not.toMatch(/Confidence:/);
+    expect(addition).not.toMatch(/Accessed: 2x/);
+    expect(addition).not.toMatch(/Decay:/);
+    expect(addition).not.toMatch(/\[2026-04-21T/);
+  });
+
+  it("strips trailing JSON metadata blobs", async () => {
+    const content = [
+      "User said: I drive a Subaru.",
+      "{",
+      '  "event_id": "abc",',
+      '  "event_type": "CHAT_TURN"',
+      "}",
+    ].join("\n");
+    mockSearchReturns([{ id: "m1", content, similarity: 0.9 }]);
+    const engine = makeEngine();
+
+    const result = await engine.assemble({
+      sessionId: "s",
+      messages: [{ role: "user", content: "q" }],
+    });
+
+    expect(result.systemPromptAddition).toMatch(/User said: I drive a Subaru\./);
+    expect(result.systemPromptAddition).not.toMatch(/event_id/);
+    expect(result.systemPromptAddition).not.toMatch(/entity_type/);
+  });
+
+  it("caps verbose memories so a single transcript dump can't dominate", async () => {
+    // 2400-char "memory" — well over the 600-char cap
+    const long = "Phil owns a Subaru. ".repeat(120);
+    mockSearchReturns([{ id: "m1", content: long, similarity: 0.9 }]);
+    const engine = makeEngine();
+
+    const result = await engine.assemble({
+      sessionId: "s",
+      messages: [{ role: "user", content: "q" }],
+    });
+
+    const addition = result.systemPromptAddition || "";
+    // Full content would be ~2400 chars; capped version ~600 + …
+    expect(addition).toMatch(/Phil owns a Subaru\./);
+    expect(addition).toMatch(/…/);
+  });
+
+  it("keeps clean content unchanged", async () => {
+    mockSearchReturns([
+      { id: "m1", content: "Phil drinks cortado.", similarity: 0.9 },
+    ]);
+    const engine = makeEngine();
+
+    const result = await engine.assemble({
+      sessionId: "s",
+      messages: [{ role: "user", content: "q" }],
+    });
+
+    expect(result.systemPromptAddition).toMatch(/Phil drinks cortado\./);
+    expect(result.systemPromptAddition).not.toMatch(/…/); // no truncation
+  });
+});

package/packages/memory/openclaw-plugin/index.js

@@ -434,10 +434,61 @@ async function tesGetApiKey(accessToken, clientId) {
 
 // --- Format helpers ---
 
+// Strip TES dashboard/metadata noise from a stored memory's content
+// before we show it to the model. Same shape as the Claude Code hook's
+// sanitizer in `hooks/scripts/shared.js` — duplicated inline here to
+// keep the published openclaw-plugin package fully standalone. Update
+// both if you change this.
+const TES_META_FIELDS =
+  "event_id|event_type|entity_type|source|clientId|correlationId|timestamp|session_id|layer_id|confidence|decay_rate|user_id";
+const MEMORY_MAX_LEN = 600;
+
+function sanitizeMemoryContent(content) {
+  if (typeof content !== "string") return content;
+  let out = content;
+  // Trailing JSON metadata blob (no `m` flag — `$` = end-of-string).
+  out = out.replace(/\n\{\s*\n[\s\S]*?\n\s*\}\s*$/, "");
+  // Inline JSON metadata blobs (2+ consecutive TES metadata fields).
+  out = out.replace(
+    new RegExp(
+      `\\{\\s*\\n(\\s*"(?:${TES_META_FIELDS})"[^\\n]*\\n){2,}\\s*\\}`,
+      "g"
+    ),
+    ""
+  );
+  // Dashboard-UI standalone lines.
+  const linePatterns = [
+    /^\s*anonymous\s*$/gm,
+    /^\s*ml_[a-z0-9_-]+_(episodic|semantic|procedural|working)\s*$/gm,
+    /^\s*\d+%\s*match\s*$/gm,
+    /^\s*Confidence:\s*\d+%\s*$/gm,
+    /^\s*Accessed:\s*\d+x?\s*$/gm,
+    /^\s*<?\s*\d+[smhd]\s*ago\s*$/gm,
+    /^\s*Decay:\s*[\d.]+\s*$/gm,
+    /^\s*Metadata\s*$/gm,
+  ];
+  for (const pat of linePatterns) out = out.replace(pat, "");
+  // Leading ISO timestamps — strip prefix, keep line content.
+  out = out.replace(/^\s*\[\d{4}-\d{2}-\d{2}T[\d:.]+Z\]\s*/gm, "");
+  // Collapse consecutive blank lines.
+  out = out.replace(/\n\s*\n\s*\n+/g, "\n\n").trim();
+  // Cap verbose transcript dumps.
+  if (out.length > MEMORY_MAX_LEN) {
+    out = out.slice(0, MEMORY_MAX_LEN).trimEnd() + "…";
+  }
+  // Fallback to original if we stripped everything.
+  const wordCount = (out.match(/\b\w{2,}\b/g) || []).length;
+  if (wordCount < 2) return content;
+  return out;
+}
+
 function formatResults(results) {
   if (!results.length) return "No relevant memories found.";
   return results
-    .map((m, i) => `${i + 1}. [${Math.round((m.similarity || 0) * 100)}%] ${m.content}`)
+    .map(
+      (m, i) =>
+        `${i + 1}. [${Math.round((m.similarity || 0) * 100)}%] ${sanitizeMemoryContent(m.content)}`
+    )
     .join("\n\n");
 }
 
@@ -644,7 +695,10 @@ export default {
           stats.lastAssembleCount = results.length;
 
           const memoryText = results
-            .map((m) => `- [${Math.round((m.similarity || 0) * 100)}%] ${m.content}`)
+            .map(
+              (m) =>
+                `- [${Math.round((m.similarity || 0) * 100)}%] ${sanitizeMemoryContent(m.content)}`
+            )
             .join("\n");
 
           // Visibility marker: instruct the model to append a footer so the

package/packages/memory/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "pentatonic-memory",
   "name": "Pentatonic Memory",
   "description": "Persistent, searchable memory with multi-signal retrieval and HyDE query expansion. Local (Docker + Ollama) or hosted (Pentatonic TES).",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "kind": "context-engine",
   "configSchema": {
     "type": "object",

package/packages/memory/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pentatonic-ai/openclaw-memory-plugin",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "Pentatonic Memory plugin for OpenClaw — persistent, searchable memory with multi-signal retrieval and HyDE query expansion",
   "type": "module",
   "main": "index.js",
@@ -24,7 +24,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Pentatonic-Ltd/ai-agent-sdk.git",
+    "url": "git+https://github.com/Pentatonic-Ltd/ai-agent-sdk.git",
     "directory": "packages/memory/openclaw-plugin"
   },
   "keywords": ["openclaw", "plugin", "memory", "context-engine", "pentatonic", "tes"]

package/packages/memory/src/__tests__/api-contract.test.js

@@ -263,6 +263,62 @@ describe("createAIClient", () => {
     await client.chat([{ role: "user", content: "q" }]);
     expect(hitUrl).toBe("http://localhost:11434/v1/chat/completions");
   });
+
+  it("embedBatch sends all inputs in one HTTP call", async () => {
+    let callCount = 0;
+    let lastBody;
+    globalThis.fetch = async (_url, opts) => {
+      callCount++;
+      lastBody = JSON.parse(opts.body);
+      return {
+        ok: true,
+        json: async () => ({
+          data: lastBody.input.map((_, i) => ({
+            embedding: [0.1, 0.2, 0.3],
+            index: i,
+          })),
+        }),
+      };
+    };
+    const client = createAIClient({
+      url: "http://localhost:11434/v1",
+      model: "m",
+    });
+    const out = await client.embedBatch(["a", "b", "c"], "passage");
+    expect(callCount).toBe(1);
+    expect(lastBody.input).toEqual(["a", "b", "c"]);
+    expect(out.length).toBe(3);
+    expect(out.every((r) => r.embedding.length === 3)).toBe(true);
+  });
+
+  it("embedBatch returns nulls on non-2xx without throwing", async () => {
+    globalThis.fetch = async () => ({ ok: false, json: async () => ({}) });
+    const client = createAIClient({
+      url: "http://localhost:11434/v1",
+      model: "m",
+    });
+    const out = await client.embedBatch(["a", "b"]);
+    expect(out).toEqual([null, null]);
+  });
+
+  it("embedBatch parses Ollama/Pentatonic-style {embeddings: [[...]]} response", async () => {
+    globalThis.fetch = async () => ({
+      ok: true,
+      json: async () => ({
+        embeddings: [
+          [0.1, 0.2],
+          [0.3, 0.4],
+        ],
+      }),
+    });
+    const client = createAIClient({
+      url: "http://localhost:11434/v1",
+      model: "m",
+    });
+    const out = await client.embedBatch(["x", "y"]);
+    expect(out[0].embedding).toEqual([0.1, 0.2]);
+    expect(out[1].embedding).toEqual([0.3, 0.4]);
+  });
 });
 
 // --- Search options contract ---

package/packages/memory/src/__tests__/hosted.test.js

@@ -0,0 +1,253 @@
+/**
+ * Tests for the hosted-mode helpers (semanticSearchMemories +
+ * createModuleEvent over HTTPS with a tes_* bearer).
+ *
+ * Stub global fetch and assert request/response shape — the helpers
+ * have no other side effects, so this is sufficient.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import {
+  hostedSearch,
+  hostedEmitChatTurn,
+  hostedStoreMemory,
+  buildHostedHeaders,
+} from "../hosted.js";
+
+const CONFIG = {
+  endpoint: "https://acme.api.example.com",
+  clientId: "acme",
+  apiKey: "tes_acme_xxxxxxxxxxxxxxxx",
+};
+
+const SVC_CONFIG = {
+  endpoint: "https://acme.api.example.com",
+  clientId: "acme",
+  apiKey: "internal-service-key",
+};
+
+let originalFetch;
+let lastCall;
+
+function stubFetch(handler) {
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url, init) => {
+    lastCall = {
+      url: url.toString(),
+      headers: init?.headers || {},
+      body: init?.body ? JSON.parse(init.body) : null,
+    };
+    return handler(lastCall);
+  };
+}
+
+afterEach(() => {
+  if (originalFetch) globalThis.fetch = originalFetch;
+  originalFetch = null;
+  lastCall = null;
+});
+
+// =============================================================================
+// buildHostedHeaders
+// =============================================================================
+
+describe("buildHostedHeaders", () => {
+  it("uses Bearer auth for tes_* keys", () => {
+    const headers = buildHostedHeaders(CONFIG);
+    expect(headers["Authorization"]).toBe(`Bearer ${CONFIG.apiKey}`);
+    expect(headers["x-client-id"]).toBe(CONFIG.clientId);
+    expect(headers["x-service-key"]).toBeUndefined();
+  });
+
+  it("uses x-service-key for non-tes_ keys", () => {
+    const headers = buildHostedHeaders(SVC_CONFIG);
+    expect(headers["x-service-key"]).toBe(SVC_CONFIG.apiKey);
+    expect(headers["Authorization"]).toBeUndefined();
+  });
+
+  it("accepts legacy tes_endpoint/tes_client_id/tes_api_key keys", () => {
+    const legacy = {
+      tes_endpoint: CONFIG.endpoint,
+      tes_client_id: CONFIG.clientId,
+      tes_api_key: CONFIG.apiKey,
+    };
+    const headers = buildHostedHeaders(legacy);
+    expect(headers["Authorization"]).toBe(`Bearer ${CONFIG.apiKey}`);
+  });
+
+  it("throws on incomplete config", () => {
+    expect(() => buildHostedHeaders({})).toThrow(/requires/);
+  });
+});
+
+// =============================================================================
+// hostedSearch
+// =============================================================================
+
+describe("hostedSearch", () => {
+  it("returns memories on a successful query", async () => {
+    stubFetch(() =>
+      new Response(
+        JSON.stringify({
+          data: {
+            semanticSearchMemories: [
+              { id: "m1", content: "User likes blue", similarity: 0.83 },
+            ],
+          },
+        }),
+        { status: 200 }
+      )
+    );
+
+    const out = await hostedSearch(CONFIG, "what colour", { limit: 4 });
+    expect(out.memories).toHaveLength(1);
+    expect(out.skipped).toBeUndefined();
+    expect(lastCall.body.variables.clientId).toBe("acme");
+    expect(lastCall.body.variables.limit).toBe(4);
+    expect(lastCall.headers["Authorization"]).toBe(`Bearer ${CONFIG.apiKey}`);
+  });
+
+  it("returns { memories: [], skipped: 'no_query' } when query is empty", async () => {
+    stubFetch(() => new Response("{}", { status: 200 }));
+    const out = await hostedSearch(CONFIG, "");
+    expect(out.skipped).toBe("no_query");
+  });
+
+  it("skips with tes_http_500 on 500 responses", async () => {
+    stubFetch(() => new Response("oops", { status: 500 }));
+    const out = await hostedSearch(CONFIG, "q");
+    expect(out.skipped).toBe("tes_http_500");
+    expect(out.memories).toEqual([]);
+  });
+
+  it("skips with tes_graphql:<reason> on graphql errors", async () => {
+    stubFetch(() =>
+      new Response(
+        JSON.stringify({
+          errors: [{ message: 'Module "deep-memory" is not enabled' }],
+        }),
+        { status: 200 }
+      )
+    );
+    const out = await hostedSearch(CONFIG, "q");
+    expect(out.skipped).toMatch(/^tes_graphql:/);
+  });
+
+  it("skips with tes_timeout on AbortError", async () => {
+    stubFetch(() => {
+      const err = new Error("aborted");
+      err.name = "AbortError";
+      throw err;
+    });
+    const out = await hostedSearch(CONFIG, "q", { timeoutMs: 5 });
+    expect(out.skipped).toBe("tes_timeout");
+  });
+
+  it("skips with tes_unreachable on generic fetch failure", async () => {
+    stubFetch(() => {
+      throw new Error("ECONNREFUSED");
+    });
+    const out = await hostedSearch(CONFIG, "q");
+    expect(out.skipped).toBe("tes_unreachable");
+  });
+});
+
+// =============================================================================
+// hostedEmitChatTurn
+// =============================================================================
+
+describe("hostedEmitChatTurn", () => {
+  it("emits createModuleEvent with conversation-analytics moduleId", async () => {
+    stubFetch(() =>
+      new Response(
+        JSON.stringify({
+          data: { createModuleEvent: { success: true, eventId: "evt_1" } },
+        }),
+        { status: 200 }
+      )
+    );
+
+    const out = await hostedEmitChatTurn(
+      CONFIG,
+      {
+        userMessage: "hi",
+        assistantResponse: "hello!",
+        model: "gpt-4o",
+        sessionId: "sess_1",
+      },
+      { source: "my-app" }
+    );
+
+    expect(out.ok).toBe(true);
+    expect(out.eventId).toBe("evt_1");
+    expect(lastCall.body.variables.moduleId).toBe("conversation-analytics");
+    expect(lastCall.body.variables.input.eventType).toBe("CHAT_TURN");
+    expect(lastCall.body.variables.input.data.attributes.source).toBe("my-app");
+    expect(lastCall.body.variables.input.data.attributes.user_message).toBe(
+      "hi"
+    );
+    expect(lastCall.body.variables.input.data.entity_id).toBe("sess_1");
+  });
+
+  it("skips empty turns (no user + no assistant text)", async () => {
+    stubFetch(() => new Response("{}", { status: 200 }));
+    const out = await hostedEmitChatTurn(CONFIG, {});
+    expect(out.skipped).toBe("empty_turn");
+  });
+
+  it("merges payload.extra into attributes", async () => {
+    stubFetch(() =>
+      new Response(
+        JSON.stringify({
+          data: { createModuleEvent: { success: true, eventId: "x" } },
+        }),
+        { status: 200 }
+      )
+    );
+    await hostedEmitChatTurn(CONFIG, {
+      userMessage: "u",
+      assistantResponse: "a",
+      extra: { tes_skipped_reason: "passthrough_mode", custom_flag: 1 },
+    });
+    const attrs = lastCall.body.variables.input.data.attributes;
+    expect(attrs.tes_skipped_reason).toBe("passthrough_mode");
+    expect(attrs.custom_flag).toBe(1);
+  });
+});
+
+// =============================================================================
+// hostedStoreMemory
+// =============================================================================
+
+describe("hostedStoreMemory", () => {
+  it("emits STORE_MEMORY against deep-memory", async () => {
+    stubFetch(() =>
+      new Response(
+        JSON.stringify({
+          data: { createModuleEvent: { success: true, eventId: "stored" } },
+        }),
+        { status: 200 }
+      )
+    );
+    const out = await hostedStoreMemory(
+      CONFIG,
+      "User owns a Subaru",
+      { session_id: "abc" },
+      { source: "my-app" }
+    );
+    expect(out.ok).toBe(true);
+    expect(lastCall.body.variables.moduleId).toBe("deep-memory");
+    expect(lastCall.body.variables.input.eventType).toBe("STORE_MEMORY");
+    expect(lastCall.body.variables.input.data.attributes.content).toBe(
+      "User owns a Subaru"
+    );
+    expect(lastCall.body.variables.input.data.attributes.source).toBe("my-app");
+    expect(lastCall.body.variables.input.data.entity_id).toBe("abc");
+  });
+
+  it("skips with no_content if content is empty", async () => {
+    stubFetch(() => new Response("{}", { status: 200 }));
+    const out = await hostedStoreMemory(CONFIG, "");
+    expect(out.skipped).toBe("no_content");
+  });
+});

package/packages/memory/src/__tests__/sanitize.test.js

@@ -0,0 +1,103 @@
+/**
+ * Unit tests for the shared memory-content sanitizer.
+ *
+ * Same invariants the Claude Code hook tests already cover — we
+ * assert them here against the canonical module too so the published
+ * openclaw-plugin's inline copy and the hooks/scripts inline copy
+ * both have a reference to check against.
+ */
+
+import {
+  sanitizeMemoryContent,
+  MEMORY_MAX_LEN,
+} from "../sanitize.js";
+
+describe("sanitizeMemoryContent", () => {
+  it("strips leading ISO timestamps on each line", () => {
+    const out = sanitizeMemoryContent(
+      "[2026-04-21T11:47:04.826Z] Phil owns a Subaru."
+    );
+    expect(out).toBe("Phil owns a Subaru.");
+  });
+
+  it("strips standalone dashboard metadata lines", () => {
+    const input = [
+      "Phil owns a Subaru.",
+      "anonymous",
+      "ml_phil-h-claude_episodic",
+      "100% match",
+      "Confidence: 100%",
+      "Accessed: 2x",
+      "<1h ago",
+      "Decay: 0.05",
+      "Metadata",
+    ].join("\n");
+    expect(sanitizeMemoryContent(input)).toBe("Phil owns a Subaru.");
+  });
+
+  it("strips trailing JSON metadata blob", () => {
+    const input = [
+      "Phil has two dogs named Max and Luna.",
+      "{",
+      '  "event_id": "abc-123",',
+      '  "event_type": "CHAT_TURN"',
+      "}",
+    ].join("\n");
+    expect(sanitizeMemoryContent(input)).toBe(
+      "Phil has two dogs named Max and Luna."
+    );
+  });
+
+  it("strips inline JSON metadata blobs with TES-style fields", () => {
+    const input = [
+      "User said: I have a Subaru.",
+      "{",
+      '  "event_id": "abc",',
+      '  "event_type": "CHAT_TURN",',
+      '  "entity_type": "conversation"',
+      "}",
+      "The next turn continued...",
+    ].join("\n");
+    const out = sanitizeMemoryContent(input);
+    expect(out).toMatch(/User said: I have a Subaru\./);
+    expect(out).toMatch(/The next turn continued\.\.\./);
+    expect(out).not.toMatch(/event_id/);
+  });
+
+  it("does NOT strip legitimate JSON code samples", () => {
+    const input = [
+      "Here's how to configure the client:",
+      "{",
+      '  "apiKey": "xxx",',
+      '  "endpoint": "https://api.test"',
+      "}",
+      "Then instantiate it.",
+    ].join("\n");
+    const out = sanitizeMemoryContent(input);
+    expect(out).toMatch(/apiKey/);
+    expect(out).toMatch(/endpoint/);
+  });
+
+  it("falls back to original when stripping would leave almost nothing", () => {
+    const input = "anonymous\nml_phil-h-claude_episodic\n100% match";
+    expect(sanitizeMemoryContent(input)).toBe(input);
+  });
+
+  it("is a no-op for clean content", () => {
+    const clean = "Phil prefers espresso in the morning, tea in the afternoon.";
+    expect(sanitizeMemoryContent(clean)).toBe(clean);
+  });
+
+  it("caps verbose content at MEMORY_MAX_LEN with ellipsis", () => {
+    const long = "fact. ".repeat(200); // 1200 chars
+    const out = sanitizeMemoryContent(long);
+    expect(out.length).toBeLessThanOrEqual(MEMORY_MAX_LEN + 1);
+    expect(out.endsWith("…")).toBe(true);
+  });
+
+  it("handles non-string input safely", () => {
+    expect(sanitizeMemoryContent(undefined)).toBeUndefined();
+    expect(sanitizeMemoryContent(null)).toBeNull();
+    expect(sanitizeMemoryContent(42)).toBe(42);
+  });
+});